module_name,module_version,full_name,prefix,obj_name,obj_doc,object_type,arg_full,0,1,2,3,4,5,6,7,8,9,10,11
scipy,1.1.0,scipy.__config__.get_info,__config__,get_info,"Python Library Documentation: function get_info in module scipy.__config__

get_info(name)
",function,"('(name)',)",scipy,1.1.0,scipy.__config__.get_info,__config__,get_info,"Python Library Documentation: function get_info in module scipy.__config__

get_info(name)
",function,"('name',)","(nan,)","(nan,)","('arg_info',)","('(name)',)"
scipy,1.1.0,scipy.__config__.show,__config__,show,"Python Library Documentation: function show in module scipy.__config__

show()
",function,"('()',)",scipy,1.1.0,scipy.__config__.show,__config__,show,"Python Library Documentation: function show in module scipy.__config__

show()
",function,(),(),(),(),"('()',)"
scipy,1.1.0,scipy._build_utils._fortran.get_g77_abi_wrappers,_build_utils._fortran,get_g77_abi_wrappers,"Python Library Documentation: function get_g77_abi_wrappers in module scipy._build_utils._fortran

get_g77_abi_wrappers(info)
    Returns file names of source files containing Fortran ABI wrapper
    routines.
",function,"('(info)',)",scipy,1.1.0,scipy._build_utils._fortran.get_g77_abi_wrappers,_build_utils._fortran,get_g77_abi_wrappers,"Python Library Documentation: function get_g77_abi_wrappers in module scipy._build_utils._fortran

get_g77_abi_wrappers(info)
    Returns file names of source files containing Fortran ABI wrapper
    routines.
",function,"('info',)","(nan,)","(nan,)","('arg_info',)","('(info)',)"
scipy,1.1.0,scipy._build_utils._fortran.get_sgemv_fix,_build_utils._fortran,get_sgemv_fix,"Python Library Documentation: function get_sgemv_fix in module scipy._build_utils._fortran

get_sgemv_fix(info)
    Returns source file needed to correct SGEMV
",function,"('(info)',)",scipy,1.1.0,scipy._build_utils._fortran.get_sgemv_fix,_build_utils._fortran,get_sgemv_fix,"Python Library Documentation: function get_sgemv_fix in module scipy._build_utils._fortran

get_sgemv_fix(info)
    Returns source file needed to correct SGEMV
",function,"('info',)","(nan,)","(nan,)","('arg_info',)","('(info)',)"
scipy,1.1.0,scipy._build_utils._fortran.needs_g77_abi_wrapper,_build_utils._fortran,needs_g77_abi_wrapper,"Python Library Documentation: function needs_g77_abi_wrapper in module scipy._build_utils._fortran

needs_g77_abi_wrapper(info)
    Returns True if g77 ABI wrapper must be used.
",function,"('(info)',)",scipy,1.1.0,scipy._build_utils._fortran.needs_g77_abi_wrapper,_build_utils._fortran,needs_g77_abi_wrapper,"Python Library Documentation: function needs_g77_abi_wrapper in module scipy._build_utils._fortran

needs_g77_abi_wrapper(info)
    Returns True if g77 ABI wrapper must be used.
",function,"('info',)","(nan,)","(nan,)","('arg_info',)","('(info)',)"
scipy,1.1.0,scipy._build_utils._fortran.needs_sgemv_fix,_build_utils._fortran,needs_sgemv_fix,"Python Library Documentation: function needs_sgemv_fix in module scipy._build_utils._fortran

needs_sgemv_fix(info)
    Returns True if SGEMV must be fixed.
",function,"('(info)',)",scipy,1.1.0,scipy._build_utils._fortran.needs_sgemv_fix,_build_utils._fortran,needs_sgemv_fix,"Python Library Documentation: function needs_sgemv_fix in module scipy._build_utils._fortran

needs_sgemv_fix(info)
    Returns True if SGEMV must be fixed.
",function,"('info',)","(nan,)","(nan,)","('arg_info',)","('(info)',)"
scipy,1.1.0,scipy._build_utils._fortran.newer,_build_utils._fortran,newer,"Python Library Documentation: function newer in module distutils.dep_util

newer(source, target)
    Return true if 'source' exists and is more recently modified than
    'target', or if 'source' exists and 'target' doesn't.  Return false if
    both exist and 'target' is the same age or younger than 'source'.
    Raise DistutilsFileError if 'source' does not exist.
",function,"('(source, target)',)",scipy,1.1.0,scipy._build_utils._fortran.newer,_build_utils._fortran,newer,"Python Library Documentation: function newer in module distutils.dep_util

newer(source, target)
    Return true if 'source' exists and is more recently modified than
    'target', or if 'source' exists and 'target' doesn't.  Return false if
    both exist and 'target' is the same age or younger than 'source'.
    Raise DistutilsFileError if 'source' does not exist.
",function,"('source', 'target')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(source, target)',)"
scipy,1.1.0,scipy._build_utils._fortran.split_fortran_files,_build_utils._fortran,split_fortran_files,"Python Library Documentation: function split_fortran_files in module scipy._build_utils._fortran

split_fortran_files(source_dir, subroutines=None)
    Split each file in `source_dir` into separate files per subroutine.
    
    Parameters
    ----------
    source_dir : str
        Full path to directory in which sources to be split are located.
    subroutines : list of str, optional
        Subroutines to split. (Default: all)
    
    Returns
    -------
    fnames : list of str
        List of file names (not including any path) that were created
        in `source_dir`.
    
    Notes
    -----
    This function is useful for code that can't be compiled with g77 because of
    type casting errors which do work with gfortran.
    
    Created files are named: ``original_name + '_subr_i' + '.f'``, with ``i``
    starting at zero and ending at ``num_subroutines_in_file - 1``.
",function,"('(source_dir, subroutines=None)',)",scipy,1.1.0,scipy._build_utils._fortran.split_fortran_files,_build_utils._fortran,split_fortran_files,"Python Library Documentation: function split_fortran_files in module scipy._build_utils._fortran

split_fortran_files(source_dir, subroutines=None)
    Split each file in `source_dir` into separate files per subroutine.
    
    Parameters
    ----------
    source_dir : str
        Full path to directory in which sources to be split are located.
    subroutines : list of str, optional
        Subroutines to split. (Default: all)
    
    Returns
    -------
    fnames : list of str
        List of file names (not including any path) that were created
        in `source_dir`.
    
    Notes
    -----
    This function is useful for code that can't be compiled with g77 because of
    type casting errors which do work with gfortran.
    
    Created files are named: ``original_name + '_subr_i' + '.f'``, with ``i``
    starting at zero and ending at ``num_subroutines_in_file - 1``.
",function,"('source_dir', 'subroutines')","(nan, None)","(nan, 'NoneType')","('arg_info', 'arg_info')","('(source_dir, subroutines=None)',)"
scipy,1.1.0,scipy._build_utils._fortran.uses_accelerate,_build_utils._fortran,uses_accelerate,"Python Library Documentation: function uses_accelerate in module scipy._build_utils._fortran

uses_accelerate(info)
",function,"('(info)',)",scipy,1.1.0,scipy._build_utils._fortran.uses_accelerate,_build_utils._fortran,uses_accelerate,"Python Library Documentation: function uses_accelerate in module scipy._build_utils._fortran

uses_accelerate(info)
",function,"('info',)","(nan,)","(nan,)","('arg_info',)","('(info)',)"
scipy,1.1.0,scipy._build_utils._fortran.uses_mkl,_build_utils._fortran,uses_mkl,"Python Library Documentation: function uses_mkl in module scipy._build_utils._fortran

uses_mkl(info)
",function,"('(info)',)",scipy,1.1.0,scipy._build_utils._fortran.uses_mkl,_build_utils._fortran,uses_mkl,"Python Library Documentation: function uses_mkl in module scipy._build_utils._fortran

uses_mkl(info)
",function,"('info',)","(nan,)","(nan,)","('arg_info',)","('(info)',)"
scipy,1.1.0,scipy._build_utils._fortran.uses_veclib,_build_utils._fortran,uses_veclib,"Python Library Documentation: function uses_veclib in module scipy._build_utils._fortran

uses_veclib(info)
",function,"('(info)',)",scipy,1.1.0,scipy._build_utils._fortran.uses_veclib,_build_utils._fortran,uses_veclib,"Python Library Documentation: function uses_veclib in module scipy._build_utils._fortran

uses_veclib(info)
",function,"('info',)","(nan,)","(nan,)","('arg_info',)","('(info)',)"
scipy,1.1.0,scipy._lib._ccallback.CData,_lib._ccallback,CData,"Python Library Documentation: class CData in module scipy._lib._ccallback

class CData(builtins.object)
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy._lib._ccallback.CData,_lib._ccallback,CData,"Python Library Documentation: class CData in module scipy._lib._ccallback

class CData(builtins.object)
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy._lib._ccallback.LowLevelCallable,_lib._ccallback,LowLevelCallable,"Python Library Documentation: class LowLevelCallable in module scipy._lib._ccallback

class LowLevelCallable(builtins.tuple)
 |  Low-level callback function.
 |  
 |  Parameters
 |  ----------
 |  function : {PyCapsule, ctypes function pointer, cffi function pointer}
 |      Low-level callback function.
 |  user_data : {PyCapsule, ctypes void pointer, cffi void pointer}
 |      User data to pass on to the callback function.
 |  signature : str, optional
 |      Signature of the function. If omitted, determined from *function*,
 |      if possible.
 |  
 |  Attributes
 |  ----------
 |  function
 |      Callback function given
 |  user_data
 |      User data given
 |  signature
 |      Signature of the function.
 |  
 |  Methods
 |  -------
 |  from_cython
 |      Class method for constructing callables from Cython C-exported
 |      functions.
 |  
 |  Notes
 |  -----
 |  The argument ``function`` can be one of:
 |  
 |  - PyCapsule, whose name contains the C function signature
 |  - ctypes function pointer
 |  - cffi function pointer
 |  
 |  The signature of the low-level callback must match one of  those expected 
 |  by the routine it is passed to.
 |  
 |  If constructing low-level functions from a PyCapsule, the name of the 
 |  capsule must be the corresponding signature, in the format::
 |  
 |      return_type (arg1_type, arg2_type, ...)
 |  
 |  For example::
 |  
 |      ""void (double)""
 |      ""double (double, int *, void *)""
 |  
 |  The context of a PyCapsule passed in as ``function`` is used as ``user_data``, 
 |  if an explicit value for `user_data` was not given.
 |  
 |  Method resolution order:
 |      LowLevelCallable
 |      builtins.tuple
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __getitem__(self, idx)
 |      Return self[key].
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_cython(module, name, user_data=None, signature=None) from builtins.type
 |      Create a low-level callback function from an exported Cython function.
 |      
 |      Parameters
 |      ----------
 |      module : module
 |          Cython module where the exported function resides
 |      name : str
 |          Name of the exported function
 |      user_data : {PyCapsule, ctypes void pointer, cffi void pointer}, optional
 |          User data to pass on to the callback function.
 |      signature : str, optional
 |          Signature of the function. If omitted, determined from *function*.
 |  
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |  
 |  __new__(cls, function, user_data=None, signature=None)
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  function
 |  
 |  signature
 |  
 |  user_data
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.tuple:
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getnewargs__(...)
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.n
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __rmul__(self, value, /)
 |      Return self*value.
 |  
 |  count(...)
 |      T.count(value) -> integer -- return number of occurrences of value
 |  
 |  index(...)
 |      T.index(value, [start, [stop]]) -> integer -- return first index of value.
 |      Raises ValueError if the value is not present.
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy._lib._ccallback.LowLevelCallable,_lib._ccallback,LowLevelCallable,"Python Library Documentation: class LowLevelCallable in module scipy._lib._ccallback

class LowLevelCallable(builtins.tuple)
 |  Low-level callback function.
 |  
 |  Parameters
 |  ----------
 |  function : {PyCapsule, ctypes function pointer, cffi function pointer}
 |      Low-level callback function.
 |  user_data : {PyCapsule, ctypes void pointer, cffi void pointer}
 |      User data to pass on to the callback function.
 |  signature : str, optional
 |      Signature of the function. If omitted, determined from *function*,
 |      if possible.
 |  
 |  Attributes
 |  ----------
 |  function
 |      Callback function given
 |  user_data
 |      User data given
 |  signature
 |      Signature of the function.
 |  
 |  Methods
 |  -------
 |  from_cython
 |      Class method for constructing callables from Cython C-exported
 |      functions.
 |  
 |  Notes
 |  -----
 |  The argument ``function`` can be one of:
 |  
 |  - PyCapsule, whose name contains the C function signature
 |  - ctypes function pointer
 |  - cffi function pointer
 |  
 |  The signature of the low-level callback must match one of  those expected 
 |  by the routine it is passed to.
 |  
 |  If constructing low-level functions from a PyCapsule, the name of the 
 |  capsule must be the corresponding signature, in the format::
 |  
 |      return_type (arg1_type, arg2_type, ...)
 |  
 |  For example::
 |  
 |      ""void (double)""
 |      ""double (double, int *, void *)""
 |  
 |  The context of a PyCapsule passed in as ``function`` is used as ``user_data``, 
 |  if an explicit value for `user_data` was not given.
 |  
 |  Method resolution order:
 |      LowLevelCallable
 |      builtins.tuple
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __getitem__(self, idx)
 |      Return self[key].
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_cython(module, name, user_data=None, signature=None) from builtins.type
 |      Create a low-level callback function from an exported Cython function.
 |      
 |      Parameters
 |      ----------
 |      module : module
 |          Cython module where the exported function resides
 |      name : str
 |          Name of the exported function
 |      user_data : {PyCapsule, ctypes void pointer, cffi void pointer}, optional
 |          User data to pass on to the callback function.
 |      signature : str, optional
 |          Signature of the function. If omitted, determined from *function*.
 |  
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |  
 |  __new__(cls, function, user_data=None, signature=None)
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  function
 |  
 |  signature
 |  
 |  user_data
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.tuple:
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getnewargs__(...)
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.n
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __rmul__(self, value, /)
 |      Return self*value.
 |  
 |  count(...)
 |      T.count(value) -> integer -- return number of occurrences of value
 |  
 |  index(...)
 |      T.index(value, [start, [stop]]) -> integer -- return first index of value.
 |      Raises ValueError if the value is not present.
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy._lib._ccallback.LowLevelCallable._parse_callback,_lib._ccallback.LowLevelCallable,_parse_callback,"Python Library Documentation: method _parse_callback in module scipy._lib._ccallback

_parse_callback(obj, user_data=None, signature=None) method of builtins.type instance
",method,"('(obj, user_data=None, signature=None)',)",scipy,1.1.0,scipy._lib._ccallback.LowLevelCallable._parse_callback,_lib._ccallback.LowLevelCallable,_parse_callback,"Python Library Documentation: method _parse_callback in module scipy._lib._ccallback

_parse_callback(obj, user_data=None, signature=None) method of builtins.type instance
",method,"('cls', 'obj', 'user_data', 'signature')","(nan, nan, None, None)","(nan, nan, 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(obj, user_data=None, signature=None)',)"
scipy,1.1.0,scipy._lib._ccallback.LowLevelCallable.from_cython,_lib._ccallback.LowLevelCallable,from_cython,"Python Library Documentation: method from_cython in module scipy._lib._ccallback

from_cython(module, name, user_data=None, signature=None) method of builtins.type instance
    Create a low-level callback function from an exported Cython function.
    
    Parameters
    ----------
    module : module
        Cython module where the exported function resides
    name : str
        Name of the exported function
    user_data : {PyCapsule, ctypes void pointer, cffi void pointer}, optional
        User data to pass on to the callback function.
    signature : str, optional
        Signature of the function. If omitted, determined from *function*.
",method,"('(module, name, user_data=None, signature=None)',)",scipy,1.1.0,scipy._lib._ccallback.LowLevelCallable.from_cython,_lib._ccallback.LowLevelCallable,from_cython,"Python Library Documentation: method from_cython in module scipy._lib._ccallback

from_cython(module, name, user_data=None, signature=None) method of builtins.type instance
    Create a low-level callback function from an exported Cython function.
    
    Parameters
    ----------
    module : module
        Cython module where the exported function resides
    name : str
        Name of the exported function
    user_data : {PyCapsule, ctypes void pointer, cffi void pointer}, optional
        User data to pass on to the callback function.
    signature : str, optional
        Signature of the function. If omitted, determined from *function*.
",method,"('cls', 'module', 'name', 'user_data', 'signature')","(nan, nan, nan, None, None)","(nan, nan, nan, 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(module, name, user_data=None, signature=None)',)"
scipy,1.1.0,scipy._lib._ccallback.PyCFuncPtr,_lib._ccallback,PyCFuncPtr,"Python Library Documentation: class PyCFuncPtr in module _ctypes

class PyCFuncPtr(_CData)
 |  Function Pointer
 |  
 |  Method resolution order:
 |      PyCFuncPtr
 |      _CData
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __call__(self, /, *args, **kwargs)
 |      Call self as a function.
 |  
 |  __new__(*args, **kwargs) from _ctypes.PyCFuncPtrType
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  argtypes
 |      specify the argument types
 |  
 |  errcheck
 |      a function to check for errors
 |  
 |  restype
 |      specify the result type
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _CData:
 |  
 |  __ctypes_from_outparam__(...)
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __setstate__(...)
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy._lib._ccallback.PyCFuncPtr,_lib._ccallback,PyCFuncPtr,"Python Library Documentation: class PyCFuncPtr in module _ctypes

class PyCFuncPtr(_CData)
 |  Function Pointer
 |  
 |  Method resolution order:
 |      PyCFuncPtr
 |      _CData
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __call__(self, /, *args, **kwargs)
 |      Call self as a function.
 |  
 |  __new__(*args, **kwargs) from _ctypes.PyCFuncPtrType
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  argtypes
 |      specify the argument types
 |  
 |  errcheck
 |      a function to check for errors
 |  
 |  restype
 |      specify the result type
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _CData:
 |  
 |  __ctypes_from_outparam__(...)
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __setstate__(...)
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy._lib._ccallback._get_cffi_data,_lib._ccallback,_get_cffi_data,"Python Library Documentation: function _get_cffi_data in module scipy._lib._ccallback

_get_cffi_data(data)
",function,"('(data)',)",scipy,1.1.0,scipy._lib._ccallback._get_cffi_data,_lib._ccallback,_get_cffi_data,"Python Library Documentation: function _get_cffi_data in module scipy._lib._ccallback

_get_cffi_data(data)
",function,"('data',)","(nan,)","(nan,)","('arg_info',)","('(data)',)"
scipy,1.1.0,scipy._lib._ccallback._get_cffi_func,_lib._ccallback,_get_cffi_func,"Python Library Documentation: function _get_cffi_func in module scipy._lib._ccallback

_get_cffi_func(func, signature=None)
",function,"('(func, signature=None)',)",scipy,1.1.0,scipy._lib._ccallback._get_cffi_func,_lib._ccallback,_get_cffi_func,"Python Library Documentation: function _get_cffi_func in module scipy._lib._ccallback

_get_cffi_func(func, signature=None)
",function,"('func', 'signature')","(nan, None)","(nan, 'NoneType')","('arg_info', 'arg_info')","('(func, signature=None)',)"
scipy,1.1.0,scipy._lib._ccallback._get_ctypes_data,_lib._ccallback,_get_ctypes_data,"Python Library Documentation: function _get_ctypes_data in module scipy._lib._ccallback

_get_ctypes_data(data)
",function,"('(data)',)",scipy,1.1.0,scipy._lib._ccallback._get_ctypes_data,_lib._ccallback,_get_ctypes_data,"Python Library Documentation: function _get_ctypes_data in module scipy._lib._ccallback

_get_ctypes_data(data)
",function,"('data',)","(nan,)","(nan,)","('arg_info',)","('(data)',)"
scipy,1.1.0,scipy._lib._ccallback._get_ctypes_func,_lib._ccallback,_get_ctypes_func,"Python Library Documentation: function _get_ctypes_func in module scipy._lib._ccallback

_get_ctypes_func(func, signature=None)
",function,"('(func, signature=None)',)",scipy,1.1.0,scipy._lib._ccallback._get_ctypes_func,_lib._ccallback,_get_ctypes_func,"Python Library Documentation: function _get_ctypes_func in module scipy._lib._ccallback

_get_ctypes_func(func, signature=None)
",function,"('func', 'signature')","(nan, None)","(nan, 'NoneType')","('arg_info', 'arg_info')","('(func, signature=None)',)"
scipy,1.1.0,scipy._lib._ccallback._import_cffi,_lib._ccallback,_import_cffi,"Python Library Documentation: function _import_cffi in module scipy._lib._ccallback

_import_cffi()
",function,"('()',)",scipy,1.1.0,scipy._lib._ccallback._import_cffi,_lib._ccallback,_import_cffi,"Python Library Documentation: function _import_cffi in module scipy._lib._ccallback

_import_cffi()
",function,(),(),(),(),"('()',)"
scipy,1.1.0,scipy._lib._ccallback._typename_from_ctypes,_lib._ccallback,_typename_from_ctypes,"Python Library Documentation: function _typename_from_ctypes in module scipy._lib._ccallback

_typename_from_ctypes(item)
",function,"('(item)',)",scipy,1.1.0,scipy._lib._ccallback._typename_from_ctypes,_lib._ccallback,_typename_from_ctypes,"Python Library Documentation: function _typename_from_ctypes in module scipy._lib._ccallback

_typename_from_ctypes(item)
",function,"('item',)","(nan,)","(nan,)","('arg_info',)","('(item)',)"
scipy,1.1.0,scipy._lib._ccallback_c.plus1_t,_lib._ccallback_c,CFunctionType,"Python Library Documentation: class CFunctionType in module ctypes

class CFunctionType(_ctypes.PyCFuncPtr)
 |  Function Pointer
 |  
 |  Method resolution order:
 |      CFunctionType
 |      _ctypes.PyCFuncPtr
 |      _ctypes._CData
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _ctypes.PyCFuncPtr:
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __call__(self, /, *args, **kwargs)
 |      Call self as a function.
 |  
 |  __new__(*args, **kwargs) from _ctypes.PyCFuncPtrType
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _ctypes.PyCFuncPtr:
 |  
 |  argtypes
 |      specify the argument types
 |  
 |  errcheck
 |      a function to check for errors
 |  
 |  restype
 |      specify the result type
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _ctypes._CData:
 |  
 |  __ctypes_from_outparam__(...)
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __setstate__(...)
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy._lib._ccallback_c.plus1_t,_lib._ccallback_c,CFunctionType,"Python Library Documentation: class CFunctionType in module ctypes

class CFunctionType(_ctypes.PyCFuncPtr)
 |  Function Pointer
 |  
 |  Method resolution order:
 |      CFunctionType
 |      _ctypes.PyCFuncPtr
 |      _ctypes._CData
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _ctypes.PyCFuncPtr:
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __call__(self, /, *args, **kwargs)
 |      Call self as a function.
 |  
 |  __new__(*args, **kwargs) from _ctypes.PyCFuncPtrType
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _ctypes.PyCFuncPtr:
 |  
 |  argtypes
 |      specify the argument types
 |  
 |  errcheck
 |      a function to check for errors
 |  
 |  restype
 |      specify the result type
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _ctypes._CData:
 |  
 |  __ctypes_from_outparam__(...)
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __setstate__(...)
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy._lib._ccallback_c.plus1b_t,_lib._ccallback_c,CFunctionType,"Python Library Documentation: class CFunctionType in module ctypes

class CFunctionType(_ctypes.PyCFuncPtr)
 |  Function Pointer
 |  
 |  Method resolution order:
 |      CFunctionType
 |      _ctypes.PyCFuncPtr
 |      _ctypes._CData
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _ctypes.PyCFuncPtr:
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __call__(self, /, *args, **kwargs)
 |      Call self as a function.
 |  
 |  __new__(*args, **kwargs) from _ctypes.PyCFuncPtrType
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _ctypes.PyCFuncPtr:
 |  
 |  argtypes
 |      specify the argument types
 |  
 |  errcheck
 |      a function to check for errors
 |  
 |  restype
 |      specify the result type
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _ctypes._CData:
 |  
 |  __ctypes_from_outparam__(...)
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __setstate__(...)
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy._lib._ccallback_c.plus1b_t,_lib._ccallback_c,CFunctionType,"Python Library Documentation: class CFunctionType in module ctypes

class CFunctionType(_ctypes.PyCFuncPtr)
 |  Function Pointer
 |  
 |  Method resolution order:
 |      CFunctionType
 |      _ctypes.PyCFuncPtr
 |      _ctypes._CData
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _ctypes.PyCFuncPtr:
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __call__(self, /, *args, **kwargs)
 |      Call self as a function.
 |  
 |  __new__(*args, **kwargs) from _ctypes.PyCFuncPtrType
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _ctypes.PyCFuncPtr:
 |  
 |  argtypes
 |      specify the argument types
 |  
 |  errcheck
 |      a function to check for errors
 |  
 |  restype
 |      specify the result type
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _ctypes._CData:
 |  
 |  __ctypes_from_outparam__(...)
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __setstate__(...)
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy._lib._ccallback_c.plus1bc_t,_lib._ccallback_c,CFunctionType,"Python Library Documentation: class CFunctionType in module ctypes

class CFunctionType(_ctypes.PyCFuncPtr)
 |  Function Pointer
 |  
 |  Method resolution order:
 |      CFunctionType
 |      _ctypes.PyCFuncPtr
 |      _ctypes._CData
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _ctypes.PyCFuncPtr:
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __call__(self, /, *args, **kwargs)
 |      Call self as a function.
 |  
 |  __new__(*args, **kwargs) from _ctypes.PyCFuncPtrType
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _ctypes.PyCFuncPtr:
 |  
 |  argtypes
 |      specify the argument types
 |  
 |  errcheck
 |      a function to check for errors
 |  
 |  restype
 |      specify the result type
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _ctypes._CData:
 |  
 |  __ctypes_from_outparam__(...)
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __setstate__(...)
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy._lib._ccallback_c.plus1bc_t,_lib._ccallback_c,CFunctionType,"Python Library Documentation: class CFunctionType in module ctypes

class CFunctionType(_ctypes.PyCFuncPtr)
 |  Function Pointer
 |  
 |  Method resolution order:
 |      CFunctionType
 |      _ctypes.PyCFuncPtr
 |      _ctypes._CData
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _ctypes.PyCFuncPtr:
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __call__(self, /, *args, **kwargs)
 |      Call self as a function.
 |  
 |  __new__(*args, **kwargs) from _ctypes.PyCFuncPtrType
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _ctypes.PyCFuncPtr:
 |  
 |  argtypes
 |      specify the argument types
 |  
 |  errcheck
 |      a function to check for errors
 |  
 |  restype
 |      specify the result type
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _ctypes._CData:
 |  
 |  __ctypes_from_outparam__(...)
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __setstate__(...)
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy._lib._ccallback_c.sine_t,_lib._ccallback_c,CFunctionType,"Python Library Documentation: class CFunctionType in module ctypes

class CFunctionType(_ctypes.PyCFuncPtr)
 |  Function Pointer
 |  
 |  Method resolution order:
 |      CFunctionType
 |      _ctypes.PyCFuncPtr
 |      _ctypes._CData
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _ctypes.PyCFuncPtr:
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __call__(self, /, *args, **kwargs)
 |      Call self as a function.
 |  
 |  __new__(*args, **kwargs) from _ctypes.PyCFuncPtrType
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _ctypes.PyCFuncPtr:
 |  
 |  argtypes
 |      specify the argument types
 |  
 |  errcheck
 |      a function to check for errors
 |  
 |  restype
 |      specify the result type
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _ctypes._CData:
 |  
 |  __ctypes_from_outparam__(...)
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __setstate__(...)
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy._lib._ccallback_c.sine_t,_lib._ccallback_c,CFunctionType,"Python Library Documentation: class CFunctionType in module ctypes

class CFunctionType(_ctypes.PyCFuncPtr)
 |  Function Pointer
 |  
 |  Method resolution order:
 |      CFunctionType
 |      _ctypes.PyCFuncPtr
 |      _ctypes._CData
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _ctypes.PyCFuncPtr:
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __call__(self, /, *args, **kwargs)
 |      Call self as a function.
 |  
 |  __new__(*args, **kwargs) from _ctypes.PyCFuncPtrType
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _ctypes.PyCFuncPtr:
 |  
 |  argtypes
 |      specify the argument types
 |  
 |  errcheck
 |      a function to check for errors
 |  
 |  restype
 |      specify the result type
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _ctypes._CData:
 |  
 |  __ctypes_from_outparam__(...)
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __setstate__(...)
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy._lib._testutils.FPUModeChangeWarning,_lib._testutils,FPUModeChangeWarning,"Python Library Documentation: class FPUModeChangeWarning in module scipy._lib._testutils

class FPUModeChangeWarning(builtins.RuntimeWarning)
 |  Warning about FPU mode change
 |  
 |  Method resolution order:
 |      FPUModeChangeWarning
 |      builtins.RuntimeWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.RuntimeWarning:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy._lib._testutils.FPUModeChangeWarning,_lib._testutils,FPUModeChangeWarning,"Python Library Documentation: class FPUModeChangeWarning in module scipy._lib._testutils

class FPUModeChangeWarning(builtins.RuntimeWarning)
 |  Warning about FPU mode change
 |  
 |  Method resolution order:
 |      FPUModeChangeWarning
 |      builtins.RuntimeWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.RuntimeWarning:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy._lib._testutils.PytestTester,_lib._testutils,PytestTester,"Python Library Documentation: class PytestTester in module scipy._lib._testutils

class PytestTester(builtins.object)
 |  Pytest test runner entry point.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, label='fast', verbose=1, extra_argv=None, doctests=False, coverage=False, tests=None)
 |      Call self as a function.
 |  
 |  __init__(self, module_name)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, module_name)',)",scipy,1.1.0,scipy._lib._testutils.PytestTester,_lib._testutils,PytestTester,"Python Library Documentation: class PytestTester in module scipy._lib._testutils

class PytestTester(builtins.object)
 |  Pytest test runner entry point.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, label='fast', verbose=1, extra_argv=None, doctests=False, coverage=False, tests=None)
 |      Call self as a function.
 |  
 |  __init__(self, module_name)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'module_name')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(self, module_name)',)"
scipy,1.1.0,scipy._lib._testutils._get_mem_available,_lib._testutils,_get_mem_available,"Python Library Documentation: function _get_mem_available in module scipy._lib._testutils

_get_mem_available()
    Get information about memory available, not counting swap.
",function,"('()',)",scipy,1.1.0,scipy._lib._testutils._get_mem_available,_lib._testutils,_get_mem_available,"Python Library Documentation: function _get_mem_available in module scipy._lib._testutils

_get_mem_available()
    Get information about memory available, not counting swap.
",function,(),(),(),(),"('()',)"
scipy,1.1.0,scipy._lib._testutils._parse_size,_lib._testutils,_parse_size,"Python Library Documentation: function _parse_size in module scipy._lib._testutils

_parse_size(size_str)
",function,"('(size_str)',)",scipy,1.1.0,scipy._lib._testutils._parse_size,_lib._testutils,_parse_size,"Python Library Documentation: function _parse_size in module scipy._lib._testutils

_parse_size(size_str)
",function,"('size_str',)","(nan,)","(nan,)","('arg_info',)","('(size_str)',)"
scipy,1.1.0,scipy._lib._testutils.check_free_memory,_lib._testutils,check_free_memory,"Python Library Documentation: function check_free_memory in module scipy._lib._testutils

check_free_memory(free_mb)
    Check *free_mb* of memory is available, otherwise do pytest.skip
",function,"('(free_mb)',)",scipy,1.1.0,scipy._lib._testutils.check_free_memory,_lib._testutils,check_free_memory,"Python Library Documentation: function check_free_memory in module scipy._lib._testutils

check_free_memory(free_mb)
    Check *free_mb* of memory is available, otherwise do pytest.skip
",function,"('free_mb',)","(nan,)","(nan,)","('arg_info',)","('(free_mb)',)"
scipy,1.1.0,scipy._lib._version.NumpyVersion,_lib._version,NumpyVersion,"Python Library Documentation: class NumpyVersion in module scipy._lib._version

class NumpyVersion(builtins.object)
 |  Parse and compare numpy version strings.
 |  
 |  Numpy has the following versioning scheme (numbers given are examples; they
 |  can be >9) in principle):
 |  
 |  - Released version: '1.8.0', '1.8.1', etc.
 |  - Alpha: '1.8.0a1', '1.8.0a2', etc.
 |  - Beta: '1.8.0b1', '1.8.0b2', etc.
 |  - Release candidates: '1.8.0rc1', '1.8.0rc2', etc.
 |  - Development versions: '1.8.0.dev-f1234afa' (git commit hash appended)
 |  - Development versions after a1: '1.8.0a1.dev-f1234afa',
 |                                   '1.8.0b2.dev-f1234afa',
 |                                   '1.8.1rc1.dev-f1234afa', etc.
 |  - Development versions (no git hash available): '1.8.0.dev-Unknown'
 |  
 |  Comparing needs to be done against a valid version string or other
 |  `NumpyVersion` instance.
 |  
 |  Parameters
 |  ----------
 |  vstring : str
 |      Numpy version string (``np.__version__``).
 |  
 |  Notes
 |  -----
 |  All dev versions of the same (pre-)release compare equal.
 |  
 |  Examples
 |  --------
 |  >>> from scipy._lib._version import NumpyVersion
 |  >>> if NumpyVersion(np.__version__) < '1.7.0':
 |  ...     print('skip')
 |  skip
 |  
 |  >>> NumpyVersion('1.7')  # raises ValueError, add "".0""
 |  
 |  Methods defined here:
 |  
 |  __eq__(self, other)
 |      Return self==value.
 |  
 |  __ge__(self, other)
 |      Return self>=value.
 |  
 |  __gt__(self, other)
 |      Return self>value.
 |  
 |  __init__(self, vstring)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __le__(self, other)
 |      Return self<=value.
 |  
 |  __lt__(self, other)
 |      Return self<value.
 |  
 |  __ne__(self, other)
 |      Return self!=value.
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None
",class,"('(self, vstring)',)",scipy,1.1.0,scipy._lib._version.NumpyVersion,_lib._version,NumpyVersion,"Python Library Documentation: class NumpyVersion in module scipy._lib._version

class NumpyVersion(builtins.object)
 |  Parse and compare numpy version strings.
 |  
 |  Numpy has the following versioning scheme (numbers given are examples; they
 |  can be >9) in principle):
 |  
 |  - Released version: '1.8.0', '1.8.1', etc.
 |  - Alpha: '1.8.0a1', '1.8.0a2', etc.
 |  - Beta: '1.8.0b1', '1.8.0b2', etc.
 |  - Release candidates: '1.8.0rc1', '1.8.0rc2', etc.
 |  - Development versions: '1.8.0.dev-f1234afa' (git commit hash appended)
 |  - Development versions after a1: '1.8.0a1.dev-f1234afa',
 |                                   '1.8.0b2.dev-f1234afa',
 |                                   '1.8.1rc1.dev-f1234afa', etc.
 |  - Development versions (no git hash available): '1.8.0.dev-Unknown'
 |  
 |  Comparing needs to be done against a valid version string or other
 |  `NumpyVersion` instance.
 |  
 |  Parameters
 |  ----------
 |  vstring : str
 |      Numpy version string (``np.__version__``).
 |  
 |  Notes
 |  -----
 |  All dev versions of the same (pre-)release compare equal.
 |  
 |  Examples
 |  --------
 |  >>> from scipy._lib._version import NumpyVersion
 |  >>> if NumpyVersion(np.__version__) < '1.7.0':
 |  ...     print('skip')
 |  skip
 |  
 |  >>> NumpyVersion('1.7')  # raises ValueError, add "".0""
 |  
 |  Methods defined here:
 |  
 |  __eq__(self, other)
 |      Return self==value.
 |  
 |  __ge__(self, other)
 |      Return self>=value.
 |  
 |  __gt__(self, other)
 |      Return self>value.
 |  
 |  __init__(self, vstring)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __le__(self, other)
 |      Return self<=value.
 |  
 |  __lt__(self, other)
 |      Return self<value.
 |  
 |  __ne__(self, other)
 |      Return self!=value.
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None
",class,"('self', 'vstring')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(self, vstring)',)"
scipy,1.1.0,scipy._lib.six.BytesIO,_lib.six,BytesIO,"Python Library Documentation: class BytesIO in module io

class BytesIO(_BufferedIOBase)
 |  Buffered I/O implementation using an in-memory bytes buffer.
 |  
 |  Method resolution order:
 |      BytesIO
 |      _BufferedIOBase
 |      _IOBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __getstate__(...)
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __next__(self, /)
 |      Implement next(self).
 |  
 |  __setstate__(...)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  close(self, /)
 |      Disable all I/O operations.
 |  
 |  flush(self, /)
 |      Does nothing.
 |  
 |  getbuffer(self, /)
 |      Get a read-write view over the contents of the BytesIO object.
 |  
 |  getvalue(self, /)
 |      Retrieve the entire contents of the BytesIO object.
 |  
 |  isatty(self, /)
 |      Always returns False.
 |      
 |      BytesIO objects are not connected to a TTY-like device.
 |  
 |  read(self, size=None, /)
 |      Read at most size bytes, returned as a bytes object.
 |      
 |      If the size argument is negative, read until EOF is reached.
 |      Return an empty bytes object at EOF.
 |  
 |  read1(self, size, /)
 |      Read at most size bytes, returned as a bytes object.
 |      
 |      If the size argument is negative or omitted, read until EOF is reached.
 |      Return an empty bytes object at EOF.
 |  
 |  readable(self, /)
 |      Returns True if the IO object can be read.
 |  
 |  readinto(self, buffer, /)
 |      Read bytes into buffer.
 |      
 |      Returns number of bytes read (0 for EOF), or None if the object
 |      is set not to block and has no data to read.
 |  
 |  readline(self, size=None, /)
 |      Next line from the file, as a bytes object.
 |      
 |      Retain newline.  A non-negative size argument limits the maximum
 |      number of bytes to return (an incomplete line may be returned then).
 |      Return an empty bytes object at EOF.
 |  
 |  readlines(self, size=None, /)
 |      List of bytes objects, each a line from the file.
 |      
 |      Call readline() repeatedly and return a list of the lines so read.
 |      The optional size argument, if given, is an approximate bound on the
 |      total number of bytes in the lines returned.
 |  
 |  seek(self, pos, whence=0, /)
 |      Change stream position.
 |      
 |      Seek to byte offset pos relative to position indicated by whence:
 |           0  Start of stream (the default).  pos should be >= 0;
 |           1  Current position - pos may be negative;
 |           2  End of stream - pos usually negative.
 |      Returns the new absolute position.
 |  
 |  seekable(self, /)
 |      Returns True if the IO object can be seeked.
 |  
 |  tell(self, /)
 |      Current file position, an integer.
 |  
 |  truncate(self, size=None, /)
 |      Truncate the file to at most size bytes.
 |      
 |      Size defaults to the current file position, as returned by tell().
 |      The current file position is unchanged.  Returns the new size.
 |  
 |  writable(self, /)
 |      Returns True if the IO object can be written.
 |  
 |  write(self, b, /)
 |      Write bytes to file.
 |      
 |      Return the number of bytes written.
 |  
 |  writelines(self, lines, /)
 |      Write lines to the file.
 |      
 |      Note that newlines are not added.  lines can be any iterable object
 |      producing bytes-like objects. This is equivalent to calling write() for
 |      each element.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  closed
 |      True if the file is closed.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BufferedIOBase:
 |  
 |  detach(self, /)
 |      Disconnect this buffer from its underlying raw stream and return it.
 |      
 |      After the raw stream has been detached, the buffer is in an unusable
 |      state.
 |  
 |  readinto1(self, buffer, /)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _IOBase:
 |  
 |  __del__(...)
 |  
 |  __enter__(...)
 |  
 |  __exit__(...)
 |  
 |  fileno(self, /)
 |      Returns underlying file descriptor if one exists.
 |      
 |      OSError is raised if the IO object does not use a file descriptor.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _IOBase:
 |  
 |  __dict__
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy._lib.six.BytesIO,_lib.six,BytesIO,"Python Library Documentation: class BytesIO in module io

class BytesIO(_BufferedIOBase)
 |  Buffered I/O implementation using an in-memory bytes buffer.
 |  
 |  Method resolution order:
 |      BytesIO
 |      _BufferedIOBase
 |      _IOBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __getstate__(...)
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __next__(self, /)
 |      Implement next(self).
 |  
 |  __setstate__(...)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  close(self, /)
 |      Disable all I/O operations.
 |  
 |  flush(self, /)
 |      Does nothing.
 |  
 |  getbuffer(self, /)
 |      Get a read-write view over the contents of the BytesIO object.
 |  
 |  getvalue(self, /)
 |      Retrieve the entire contents of the BytesIO object.
 |  
 |  isatty(self, /)
 |      Always returns False.
 |      
 |      BytesIO objects are not connected to a TTY-like device.
 |  
 |  read(self, size=None, /)
 |      Read at most size bytes, returned as a bytes object.
 |      
 |      If the size argument is negative, read until EOF is reached.
 |      Return an empty bytes object at EOF.
 |  
 |  read1(self, size, /)
 |      Read at most size bytes, returned as a bytes object.
 |      
 |      If the size argument is negative or omitted, read until EOF is reached.
 |      Return an empty bytes object at EOF.
 |  
 |  readable(self, /)
 |      Returns True if the IO object can be read.
 |  
 |  readinto(self, buffer, /)
 |      Read bytes into buffer.
 |      
 |      Returns number of bytes read (0 for EOF), or None if the object
 |      is set not to block and has no data to read.
 |  
 |  readline(self, size=None, /)
 |      Next line from the file, as a bytes object.
 |      
 |      Retain newline.  A non-negative size argument limits the maximum
 |      number of bytes to return (an incomplete line may be returned then).
 |      Return an empty bytes object at EOF.
 |  
 |  readlines(self, size=None, /)
 |      List of bytes objects, each a line from the file.
 |      
 |      Call readline() repeatedly and return a list of the lines so read.
 |      The optional size argument, if given, is an approximate bound on the
 |      total number of bytes in the lines returned.
 |  
 |  seek(self, pos, whence=0, /)
 |      Change stream position.
 |      
 |      Seek to byte offset pos relative to position indicated by whence:
 |           0  Start of stream (the default).  pos should be >= 0;
 |           1  Current position - pos may be negative;
 |           2  End of stream - pos usually negative.
 |      Returns the new absolute position.
 |  
 |  seekable(self, /)
 |      Returns True if the IO object can be seeked.
 |  
 |  tell(self, /)
 |      Current file position, an integer.
 |  
 |  truncate(self, size=None, /)
 |      Truncate the file to at most size bytes.
 |      
 |      Size defaults to the current file position, as returned by tell().
 |      The current file position is unchanged.  Returns the new size.
 |  
 |  writable(self, /)
 |      Returns True if the IO object can be written.
 |  
 |  write(self, b, /)
 |      Write bytes to file.
 |      
 |      Return the number of bytes written.
 |  
 |  writelines(self, lines, /)
 |      Write lines to the file.
 |      
 |      Note that newlines are not added.  lines can be any iterable object
 |      producing bytes-like objects. This is equivalent to calling write() for
 |      each element.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  closed
 |      True if the file is closed.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BufferedIOBase:
 |  
 |  detach(self, /)
 |      Disconnect this buffer from its underlying raw stream and return it.
 |      
 |      After the raw stream has been detached, the buffer is in an unusable
 |      state.
 |  
 |  readinto1(self, buffer, /)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _IOBase:
 |  
 |  __del__(...)
 |  
 |  __enter__(...)
 |  
 |  __exit__(...)
 |  
 |  fileno(self, /)
 |      Returns underlying file descriptor if one exists.
 |      
 |      OSError is raised if the IO object does not use a file descriptor.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _IOBase:
 |  
 |  __dict__
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy._lib.six.Iterator,_lib.six,object,"Python Library Documentation: class object in module builtins

class object
 |  The most base type
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy._lib.six.Iterator,_lib.six,object,"Python Library Documentation: class object in module builtins

class object
 |  The most base type
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy._lib.six.StringIO,_lib.six,StringIO,"Python Library Documentation: class StringIO in module io

class StringIO(_TextIOBase)
 |  Text I/O implementation using an in-memory buffer.
 |  
 |  The initial_value argument sets the value of object.  The newline
 |  argument is like the one of TextIOWrapper's constructor.
 |  
 |  Method resolution order:
 |      StringIO
 |      _TextIOBase
 |      _IOBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __getstate__(...)
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __next__(self, /)
 |      Implement next(self).
 |  
 |  __setstate__(...)
 |  
 |  close(self, /)
 |      Close the IO object.
 |      
 |      Attempting any further operation after the object is closed
 |      will raise a ValueError.
 |      
 |      This method has no effect if the file is already closed.
 |  
 |  getvalue(self, /)
 |      Retrieve the entire contents of the object.
 |  
 |  read(self, size=None, /)
 |      Read at most size characters, returned as a string.
 |      
 |      If the argument is negative or omitted, read until EOF
 |      is reached. Return an empty string at EOF.
 |  
 |  readable(self, /)
 |      Returns True if the IO object can be read.
 |  
 |  readline(self, size=None, /)
 |      Read until newline or EOF.
 |      
 |      Returns an empty string if EOF is hit immediately.
 |  
 |  seek(self, pos, whence=0, /)
 |      Change stream position.
 |      
 |      Seek to character offset pos relative to position indicated by whence:
 |          0  Start of stream (the default).  pos should be >= 0;
 |          1  Current position - pos must be 0;
 |          2  End of stream - pos must be 0.
 |      Returns the new absolute position.
 |  
 |  seekable(self, /)
 |      Returns True if the IO object can be seeked.
 |  
 |  tell(self, /)
 |      Tell the current file position.
 |  
 |  truncate(self, pos=None, /)
 |      Truncate size to pos.
 |      
 |      The pos argument defaults to the current file position, as
 |      returned by tell().  The current file position is unchanged.
 |      Returns the new absolute position.
 |  
 |  writable(self, /)
 |      Returns True if the IO object can be written.
 |  
 |  write(self, s, /)
 |      Write string to file.
 |      
 |      Returns the number of characters written, which is always equal to
 |      the length of the string.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  closed
 |  
 |  line_buffering
 |  
 |  newlines
 |      Line endings translated so far.
 |      
 |      Only line endings translated during reading are considered.
 |      
 |      Subclasses should override.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _TextIOBase:
 |  
 |  detach(...)
 |      Separate the underlying buffer from the TextIOBase and return it.
 |      
 |      After the underlying buffer has been detached, the TextIO is in an
 |      unusable state.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _TextIOBase:
 |  
 |  encoding
 |      Encoding of the text stream.
 |      
 |      Subclasses should override.
 |  
 |  errors
 |      The error setting of the decoder or encoder.
 |      
 |      Subclasses should override.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _IOBase:
 |  
 |  __del__(...)
 |  
 |  __enter__(...)
 |  
 |  __exit__(...)
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  fileno(self, /)
 |      Returns underlying file descriptor if one exists.
 |      
 |      OSError is raised if the IO object does not use a file descriptor.
 |  
 |  flush(self, /)
 |      Flush write buffers, if applicable.
 |      
 |      This is not implemented for read-only and non-blocking streams.
 |  
 |  isatty(self, /)
 |      Return whether this is an 'interactive' stream.
 |      
 |      Return False if it can't be determined.
 |  
 |  readlines(self, hint=-1, /)
 |      Return a list of lines from the stream.
 |      
 |      hint can be specified to control the number of lines read: no more
 |      lines will be read if the total size (in bytes/characters) of all
 |      lines so far exceeds hint.
 |  
 |  writelines(self, lines, /)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _IOBase:
 |  
 |  __dict__
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy._lib.six.StringIO,_lib.six,StringIO,"Python Library Documentation: class StringIO in module io

class StringIO(_TextIOBase)
 |  Text I/O implementation using an in-memory buffer.
 |  
 |  The initial_value argument sets the value of object.  The newline
 |  argument is like the one of TextIOWrapper's constructor.
 |  
 |  Method resolution order:
 |      StringIO
 |      _TextIOBase
 |      _IOBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __getstate__(...)
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __next__(self, /)
 |      Implement next(self).
 |  
 |  __setstate__(...)
 |  
 |  close(self, /)
 |      Close the IO object.
 |      
 |      Attempting any further operation after the object is closed
 |      will raise a ValueError.
 |      
 |      This method has no effect if the file is already closed.
 |  
 |  getvalue(self, /)
 |      Retrieve the entire contents of the object.
 |  
 |  read(self, size=None, /)
 |      Read at most size characters, returned as a string.
 |      
 |      If the argument is negative or omitted, read until EOF
 |      is reached. Return an empty string at EOF.
 |  
 |  readable(self, /)
 |      Returns True if the IO object can be read.
 |  
 |  readline(self, size=None, /)
 |      Read until newline or EOF.
 |      
 |      Returns an empty string if EOF is hit immediately.
 |  
 |  seek(self, pos, whence=0, /)
 |      Change stream position.
 |      
 |      Seek to character offset pos relative to position indicated by whence:
 |          0  Start of stream (the default).  pos should be >= 0;
 |          1  Current position - pos must be 0;
 |          2  End of stream - pos must be 0.
 |      Returns the new absolute position.
 |  
 |  seekable(self, /)
 |      Returns True if the IO object can be seeked.
 |  
 |  tell(self, /)
 |      Tell the current file position.
 |  
 |  truncate(self, pos=None, /)
 |      Truncate size to pos.
 |      
 |      The pos argument defaults to the current file position, as
 |      returned by tell().  The current file position is unchanged.
 |      Returns the new absolute position.
 |  
 |  writable(self, /)
 |      Returns True if the IO object can be written.
 |  
 |  write(self, s, /)
 |      Write string to file.
 |      
 |      Returns the number of characters written, which is always equal to
 |      the length of the string.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  closed
 |  
 |  line_buffering
 |  
 |  newlines
 |      Line endings translated so far.
 |      
 |      Only line endings translated during reading are considered.
 |      
 |      Subclasses should override.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _TextIOBase:
 |  
 |  detach(...)
 |      Separate the underlying buffer from the TextIOBase and return it.
 |      
 |      After the underlying buffer has been detached, the TextIO is in an
 |      unusable state.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _TextIOBase:
 |  
 |  encoding
 |      Encoding of the text stream.
 |      
 |      Subclasses should override.
 |  
 |  errors
 |      The error setting of the decoder or encoder.
 |      
 |      Subclasses should override.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _IOBase:
 |  
 |  __del__(...)
 |  
 |  __enter__(...)
 |  
 |  __exit__(...)
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  fileno(self, /)
 |      Returns underlying file descriptor if one exists.
 |      
 |      OSError is raised if the IO object does not use a file descriptor.
 |  
 |  flush(self, /)
 |      Flush write buffers, if applicable.
 |      
 |      This is not implemented for read-only and non-blocking streams.
 |  
 |  isatty(self, /)
 |      Return whether this is an 'interactive' stream.
 |      
 |      Return False if it can't be determined.
 |  
 |  readlines(self, hint=-1, /)
 |      Return a list of lines from the stream.
 |      
 |      hint can be specified to control the number of lines read: no more
 |      lines will be read if the total size (in bytes/characters) of all
 |      lines so far exceeds hint.
 |  
 |  writelines(self, lines, /)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _IOBase:
 |  
 |  __dict__
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy._lib.six._add_doc,_lib.six,_add_doc,"Python Library Documentation: function _add_doc in module scipy._lib.six

_add_doc(func, doc)
    Add documentation to a function.
",function,"('(func, doc)',)",scipy,1.1.0,scipy._lib.six._add_doc,_lib.six,_add_doc,"Python Library Documentation: function _add_doc in module scipy._lib.six

_add_doc(func, doc)
    Add documentation to a function.
",function,"('func', 'doc')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(func, doc)',)"
scipy,1.1.0,scipy._lib.six._import_module,_lib.six,_import_module,"Python Library Documentation: function _import_module in module scipy._lib.six

_import_module(name)
    Import module, returning the module after the last dot.
",function,"('(name)',)",scipy,1.1.0,scipy._lib.six._import_module,_lib.six,_import_module,"Python Library Documentation: function _import_module in module scipy._lib.six

_import_module(name)
    Import module, returning the module after the last dot.
",function,"('name',)","(nan,)","(nan,)","('arg_info',)","('(name)',)"
scipy,1.1.0,scipy._lib.six.b,_lib.six,b,"Python Library Documentation: function b in module scipy._lib.six

b(s)
    Byte literal
",function,"('(s)',)",scipy,1.1.0,scipy._lib.six.b,_lib.six,b,"Python Library Documentation: function b in module scipy._lib.six

b(s)
    Byte literal
",function,"('s',)","(nan,)","(nan,)","('arg_info',)","('(s)',)"
scipy,1.1.0,scipy._lib.six.binary_type,_lib.six,bytes,"Python Library Documentation: class bytes in module builtins

class bytes(object)
 |  bytes(iterable_of_ints) -> bytes
 |  bytes(string, encoding[, errors]) -> bytes
 |  bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer
 |  bytes(int) -> bytes object of size given by the parameter initialized with null bytes
 |  bytes() -> empty bytes object
 |  
 |  Construct an immutable array of bytes from:
 |    - an iterable yielding integers in range(256)
 |    - a text string encoded using the specified encoding
 |    - any object implementing the buffer API.
 |    - an integer
 |  
 |  Methods defined here:
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __getnewargs__(...)
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.n
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return self*value.
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  capitalize(...)
 |      B.capitalize() -> copy of B
 |      
 |      Return a copy of B with only its first character capitalized (ASCII)
 |      and the rest lower-cased.
 |  
 |  center(...)
 |      B.center(width[, fillchar]) -> copy of B
 |      
 |      Return B centered in a string of length width.  Padding is
 |      done using the specified fill character (default is a space).
 |  
 |  count(...)
 |      B.count(sub[, start[, end]]) -> int
 |      
 |      Return the number of non-overlapping occurrences of subsection sub in
 |      bytes B[start:end].  Optional arguments start and end are interpreted
 |      as in slice notation.
 |  
 |  decode(self, /, encoding='utf-8', errors='strict')
 |      Decode the bytes using the codec registered for encoding.
 |      
 |      encoding
 |        The encoding with which to decode the bytes.
 |      errors
 |        The error handling scheme to use for the handling of decoding errors.
 |        The default is 'strict' meaning that decoding errors raise a
 |        UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
 |        as well as any other name registered with codecs.register_error that
 |        can handle UnicodeDecodeErrors.
 |  
 |  endswith(...)
 |      B.endswith(suffix[, start[, end]]) -> bool
 |      
 |      Return True if B ends with the specified suffix, False otherwise.
 |      With optional start, test B beginning at that position.
 |      With optional end, stop comparing B at that position.
 |      suffix can also be a tuple of bytes to try.
 |  
 |  expandtabs(...)
 |      B.expandtabs(tabsize=8) -> copy of B
 |      
 |      Return a copy of B where all tab characters are expanded using spaces.
 |      If tabsize is not given, a tab size of 8 characters is assumed.
 |  
 |  find(...)
 |      B.find(sub[, start[, end]]) -> int
 |      
 |      Return the lowest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Return -1 on failure.
 |  
 |  fromhex(string, /) from builtins.type
 |      Create a bytes object from a string of hexadecimal numbers.
 |      
 |      Spaces between two numbers are accepted.
 |      Example: bytes.fromhex('B9 01EF') -> b'\\xb9\\x01\\xef'.
 |  
 |  hex(...)
 |      B.hex() -> string
 |      
 |      Create a string of hexadecimal numbers from a bytes object.
 |      Example: b'\xb9\x01\xef'.hex() -> 'b901ef'.
 |  
 |  index(...)
 |      B.index(sub[, start[, end]]) -> int
 |      
 |      Return the lowest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Raises ValueError when the subsection is not found.
 |  
 |  isalnum(...)
 |      B.isalnum() -> bool
 |      
 |      Return True if all characters in B are alphanumeric
 |      and there is at least one character in B, False otherwise.
 |  
 |  isalpha(...)
 |      B.isalpha() -> bool
 |      
 |      Return True if all characters in B are alphabetic
 |      and there is at least one character in B, False otherwise.
 |  
 |  isdigit(...)
 |      B.isdigit() -> bool
 |      
 |      Return True if all characters in B are digits
 |      and there is at least one character in B, False otherwise.
 |  
 |  islower(...)
 |      B.islower() -> bool
 |      
 |      Return True if all cased characters in B are lowercase and there is
 |      at least one cased character in B, False otherwise.
 |  
 |  isspace(...)
 |      B.isspace() -> bool
 |      
 |      Return True if all characters in B are whitespace
 |      and there is at least one character in B, False otherwise.
 |  
 |  istitle(...)
 |      B.istitle() -> bool
 |      
 |      Return True if B is a titlecased string and there is at least one
 |      character in B, i.e. uppercase characters may only follow uncased
 |      characters and lowercase characters only cased ones. Return False
 |      otherwise.
 |  
 |  isupper(...)
 |      B.isupper() -> bool
 |      
 |      Return True if all cased characters in B are uppercase and there is
 |      at least one cased character in B, False otherwise.
 |  
 |  join(self, iterable_of_bytes, /)
 |      Concatenate any number of bytes objects.
 |      
 |      The bytes whose method is called is inserted in between each pair.
 |      
 |      The result is returned as a new bytes object.
 |      
 |      Example: b'.'.join([b'ab', b'pq', b'rs']) -> b'ab.pq.rs'.
 |  
 |  ljust(...)
 |      B.ljust(width[, fillchar]) -> copy of B
 |      
 |      Return B left justified in a string of length width. Padding is
 |      done using the specified fill character (default is a space).
 |  
 |  lower(...)
 |      B.lower() -> copy of B
 |      
 |      Return a copy of B with all ASCII characters converted to lowercase.
 |  
 |  lstrip(self, bytes=None, /)
 |      Strip leading bytes contained in the argument.
 |      
 |      If the argument is omitted or None, strip leading  ASCII whitespace.
 |  
 |  partition(self, sep, /)
 |      Partition the bytes into three parts using the given separator.
 |      
 |      This will search for the separator sep in the bytes. If the separator is found,
 |      returns a 3-tuple containing the part before the separator, the separator
 |      itself, and the part after it.
 |      
 |      If the separator is not found, returns a 3-tuple containing the original bytes
 |      object and two empty bytes objects.
 |  
 |  replace(self, old, new, count=-1, /)
 |      Return a copy with all occurrences of substring old replaced by new.
 |      
 |        count
 |          Maximum number of occurrences to replace.
 |          -1 (the default value) means replace all occurrences.
 |      
 |      If the optional argument count is given, only the first count occurrences are
 |      replaced.
 |  
 |  rfind(...)
 |      B.rfind(sub[, start[, end]]) -> int
 |      
 |      Return the highest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Return -1 on failure.
 |  
 |  rindex(...)
 |      B.rindex(sub[, start[, end]]) -> int
 |      
 |      Return the highest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Raise ValueError when the subsection is not found.
 |  
 |  rjust(...)
 |      B.rjust(width[, fillchar]) -> copy of B
 |      
 |      Return B right justified in a string of length width. Padding is
 |      done using the specified fill character (default is a space)
 |  
 |  rpartition(self, sep, /)
 |      Partition the bytes into three parts using the given separator.
 |      
 |      This will search for the separator sep in the bytes, starting at the end. If
 |      the separator is found, returns a 3-tuple containing the part before the
 |      separator, the separator itself, and the part after it.
 |      
 |      If the separator is not found, returns a 3-tuple containing two empty bytes
 |      objects and the original bytes object.
 |  
 |  rsplit(self, /, sep=None, maxsplit=-1)
 |      Return a list of the sections in the bytes, using sep as the delimiter.
 |      
 |        sep
 |          The delimiter according which to split the bytes.
 |          None (the default value) means split on ASCII whitespace characters
 |          (space, tab, return, newline, formfeed, vertical tab).
 |        maxsplit
 |          Maximum number of splits to do.
 |          -1 (the default value) means no limit.
 |      
 |      Splitting is done starting at the end of the bytes and working to the front.
 |  
 |  rstrip(self, bytes=None, /)
 |      Strip trailing bytes contained in the argument.
 |      
 |      If the argument is omitted or None, strip trailing ASCII whitespace.
 |  
 |  split(self, /, sep=None, maxsplit=-1)
 |      Return a list of the sections in the bytes, using sep as the delimiter.
 |      
 |      sep
 |        The delimiter according which to split the bytes.
 |        None (the default value) means split on ASCII whitespace characters
 |        (space, tab, return, newline, formfeed, vertical tab).
 |      maxsplit
 |        Maximum number of splits to do.
 |        -1 (the default value) means no limit.
 |  
 |  splitlines(self, /, keepends=False)
 |      Return a list of the lines in the bytes, breaking at line boundaries.
 |      
 |      Line breaks are not included in the resulting list unless keepends is given and
 |      true.
 |  
 |  startswith(...)
 |      B.startswith(prefix[, start[, end]]) -> bool
 |      
 |      Return True if B starts with the specified prefix, False otherwise.
 |      With optional start, test B beginning at that position.
 |      With optional end, stop comparing B at that position.
 |      prefix can also be a tuple of bytes to try.
 |  
 |  strip(self, bytes=None, /)
 |      Strip leading and trailing bytes contained in the argument.
 |      
 |      If the argument is omitted or None, strip leading and trailing ASCII whitespace.
 |  
 |  swapcase(...)
 |      B.swapcase() -> copy of B
 |      
 |      Return a copy of B with uppercase ASCII characters converted
 |      to lowercase ASCII and vice versa.
 |  
 |  title(...)
 |      B.title() -> copy of B
 |      
 |      Return a titlecased version of B, i.e. ASCII words start with uppercase
 |      characters, all remaining cased characters have lowercase.
 |  
 |  translate(self, table, /, delete=b'')
 |      Return a copy with each character mapped by the given translation table.
 |      
 |        table
 |          Translation table, which must be a bytes object of length 256.
 |      
 |      All characters occurring in the optional argument delete are removed.
 |      The remaining characters are mapped through the given translation table.
 |  
 |  upper(...)
 |      B.upper() -> copy of B
 |      
 |      Return a copy of B with all ASCII characters converted to uppercase.
 |  
 |  zfill(...)
 |      B.zfill(width) -> copy of B
 |      
 |      Pad a numeric string B with zeros on the left, to fill a field
 |      of the specified width.  B is never truncated.
 |  
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |  
 |  maketrans(frm, to, /)
 |      Return a translation table useable for the bytes or bytearray translate method.
 |      
 |      The returned table will be one where each byte in frm is mapped to the byte at
 |      the same position in to.
 |      
 |      The bytes objects frm and to must be of the same length.
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy._lib.six.binary_type,_lib.six,bytes,"Python Library Documentation: class bytes in module builtins

class bytes(object)
 |  bytes(iterable_of_ints) -> bytes
 |  bytes(string, encoding[, errors]) -> bytes
 |  bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer
 |  bytes(int) -> bytes object of size given by the parameter initialized with null bytes
 |  bytes() -> empty bytes object
 |  
 |  Construct an immutable array of bytes from:
 |    - an iterable yielding integers in range(256)
 |    - a text string encoded using the specified encoding
 |    - any object implementing the buffer API.
 |    - an integer
 |  
 |  Methods defined here:
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __getnewargs__(...)
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.n
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return self*value.
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  capitalize(...)
 |      B.capitalize() -> copy of B
 |      
 |      Return a copy of B with only its first character capitalized (ASCII)
 |      and the rest lower-cased.
 |  
 |  center(...)
 |      B.center(width[, fillchar]) -> copy of B
 |      
 |      Return B centered in a string of length width.  Padding is
 |      done using the specified fill character (default is a space).
 |  
 |  count(...)
 |      B.count(sub[, start[, end]]) -> int
 |      
 |      Return the number of non-overlapping occurrences of subsection sub in
 |      bytes B[start:end].  Optional arguments start and end are interpreted
 |      as in slice notation.
 |  
 |  decode(self, /, encoding='utf-8', errors='strict')
 |      Decode the bytes using the codec registered for encoding.
 |      
 |      encoding
 |        The encoding with which to decode the bytes.
 |      errors
 |        The error handling scheme to use for the handling of decoding errors.
 |        The default is 'strict' meaning that decoding errors raise a
 |        UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
 |        as well as any other name registered with codecs.register_error that
 |        can handle UnicodeDecodeErrors.
 |  
 |  endswith(...)
 |      B.endswith(suffix[, start[, end]]) -> bool
 |      
 |      Return True if B ends with the specified suffix, False otherwise.
 |      With optional start, test B beginning at that position.
 |      With optional end, stop comparing B at that position.
 |      suffix can also be a tuple of bytes to try.
 |  
 |  expandtabs(...)
 |      B.expandtabs(tabsize=8) -> copy of B
 |      
 |      Return a copy of B where all tab characters are expanded using spaces.
 |      If tabsize is not given, a tab size of 8 characters is assumed.
 |  
 |  find(...)
 |      B.find(sub[, start[, end]]) -> int
 |      
 |      Return the lowest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Return -1 on failure.
 |  
 |  fromhex(string, /) from builtins.type
 |      Create a bytes object from a string of hexadecimal numbers.
 |      
 |      Spaces between two numbers are accepted.
 |      Example: bytes.fromhex('B9 01EF') -> b'\\xb9\\x01\\xef'.
 |  
 |  hex(...)
 |      B.hex() -> string
 |      
 |      Create a string of hexadecimal numbers from a bytes object.
 |      Example: b'\xb9\x01\xef'.hex() -> 'b901ef'.
 |  
 |  index(...)
 |      B.index(sub[, start[, end]]) -> int
 |      
 |      Return the lowest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Raises ValueError when the subsection is not found.
 |  
 |  isalnum(...)
 |      B.isalnum() -> bool
 |      
 |      Return True if all characters in B are alphanumeric
 |      and there is at least one character in B, False otherwise.
 |  
 |  isalpha(...)
 |      B.isalpha() -> bool
 |      
 |      Return True if all characters in B are alphabetic
 |      and there is at least one character in B, False otherwise.
 |  
 |  isdigit(...)
 |      B.isdigit() -> bool
 |      
 |      Return True if all characters in B are digits
 |      and there is at least one character in B, False otherwise.
 |  
 |  islower(...)
 |      B.islower() -> bool
 |      
 |      Return True if all cased characters in B are lowercase and there is
 |      at least one cased character in B, False otherwise.
 |  
 |  isspace(...)
 |      B.isspace() -> bool
 |      
 |      Return True if all characters in B are whitespace
 |      and there is at least one character in B, False otherwise.
 |  
 |  istitle(...)
 |      B.istitle() -> bool
 |      
 |      Return True if B is a titlecased string and there is at least one
 |      character in B, i.e. uppercase characters may only follow uncased
 |      characters and lowercase characters only cased ones. Return False
 |      otherwise.
 |  
 |  isupper(...)
 |      B.isupper() -> bool
 |      
 |      Return True if all cased characters in B are uppercase and there is
 |      at least one cased character in B, False otherwise.
 |  
 |  join(self, iterable_of_bytes, /)
 |      Concatenate any number of bytes objects.
 |      
 |      The bytes whose method is called is inserted in between each pair.
 |      
 |      The result is returned as a new bytes object.
 |      
 |      Example: b'.'.join([b'ab', b'pq', b'rs']) -> b'ab.pq.rs'.
 |  
 |  ljust(...)
 |      B.ljust(width[, fillchar]) -> copy of B
 |      
 |      Return B left justified in a string of length width. Padding is
 |      done using the specified fill character (default is a space).
 |  
 |  lower(...)
 |      B.lower() -> copy of B
 |      
 |      Return a copy of B with all ASCII characters converted to lowercase.
 |  
 |  lstrip(self, bytes=None, /)
 |      Strip leading bytes contained in the argument.
 |      
 |      If the argument is omitted or None, strip leading  ASCII whitespace.
 |  
 |  partition(self, sep, /)
 |      Partition the bytes into three parts using the given separator.
 |      
 |      This will search for the separator sep in the bytes. If the separator is found,
 |      returns a 3-tuple containing the part before the separator, the separator
 |      itself, and the part after it.
 |      
 |      If the separator is not found, returns a 3-tuple containing the original bytes
 |      object and two empty bytes objects.
 |  
 |  replace(self, old, new, count=-1, /)
 |      Return a copy with all occurrences of substring old replaced by new.
 |      
 |        count
 |          Maximum number of occurrences to replace.
 |          -1 (the default value) means replace all occurrences.
 |      
 |      If the optional argument count is given, only the first count occurrences are
 |      replaced.
 |  
 |  rfind(...)
 |      B.rfind(sub[, start[, end]]) -> int
 |      
 |      Return the highest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Return -1 on failure.
 |  
 |  rindex(...)
 |      B.rindex(sub[, start[, end]]) -> int
 |      
 |      Return the highest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Raise ValueError when the subsection is not found.
 |  
 |  rjust(...)
 |      B.rjust(width[, fillchar]) -> copy of B
 |      
 |      Return B right justified in a string of length width. Padding is
 |      done using the specified fill character (default is a space)
 |  
 |  rpartition(self, sep, /)
 |      Partition the bytes into three parts using the given separator.
 |      
 |      This will search for the separator sep in the bytes, starting at the end. If
 |      the separator is found, returns a 3-tuple containing the part before the
 |      separator, the separator itself, and the part after it.
 |      
 |      If the separator is not found, returns a 3-tuple containing two empty bytes
 |      objects and the original bytes object.
 |  
 |  rsplit(self, /, sep=None, maxsplit=-1)
 |      Return a list of the sections in the bytes, using sep as the delimiter.
 |      
 |        sep
 |          The delimiter according which to split the bytes.
 |          None (the default value) means split on ASCII whitespace characters
 |          (space, tab, return, newline, formfeed, vertical tab).
 |        maxsplit
 |          Maximum number of splits to do.
 |          -1 (the default value) means no limit.
 |      
 |      Splitting is done starting at the end of the bytes and working to the front.
 |  
 |  rstrip(self, bytes=None, /)
 |      Strip trailing bytes contained in the argument.
 |      
 |      If the argument is omitted or None, strip trailing ASCII whitespace.
 |  
 |  split(self, /, sep=None, maxsplit=-1)
 |      Return a list of the sections in the bytes, using sep as the delimiter.
 |      
 |      sep
 |        The delimiter according which to split the bytes.
 |        None (the default value) means split on ASCII whitespace characters
 |        (space, tab, return, newline, formfeed, vertical tab).
 |      maxsplit
 |        Maximum number of splits to do.
 |        -1 (the default value) means no limit.
 |  
 |  splitlines(self, /, keepends=False)
 |      Return a list of the lines in the bytes, breaking at line boundaries.
 |      
 |      Line breaks are not included in the resulting list unless keepends is given and
 |      true.
 |  
 |  startswith(...)
 |      B.startswith(prefix[, start[, end]]) -> bool
 |      
 |      Return True if B starts with the specified prefix, False otherwise.
 |      With optional start, test B beginning at that position.
 |      With optional end, stop comparing B at that position.
 |      prefix can also be a tuple of bytes to try.
 |  
 |  strip(self, bytes=None, /)
 |      Strip leading and trailing bytes contained in the argument.
 |      
 |      If the argument is omitted or None, strip leading and trailing ASCII whitespace.
 |  
 |  swapcase(...)
 |      B.swapcase() -> copy of B
 |      
 |      Return a copy of B with uppercase ASCII characters converted
 |      to lowercase ASCII and vice versa.
 |  
 |  title(...)
 |      B.title() -> copy of B
 |      
 |      Return a titlecased version of B, i.e. ASCII words start with uppercase
 |      characters, all remaining cased characters have lowercase.
 |  
 |  translate(self, table, /, delete=b'')
 |      Return a copy with each character mapped by the given translation table.
 |      
 |        table
 |          Translation table, which must be a bytes object of length 256.
 |      
 |      All characters occurring in the optional argument delete are removed.
 |      The remaining characters are mapped through the given translation table.
 |  
 |  upper(...)
 |      B.upper() -> copy of B
 |      
 |      Return a copy of B with all ASCII characters converted to uppercase.
 |  
 |  zfill(...)
 |      B.zfill(width) -> copy of B
 |      
 |      Pad a numeric string B with zeros on the left, to fill a field
 |      of the specified width.  B is never truncated.
 |  
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |  
 |  maketrans(frm, to, /)
 |      Return a translation table useable for the bytes or bytearray translate method.
 |      
 |      The returned table will be one where each byte in frm is mapped to the byte at
 |      the same position in to.
 |      
 |      The bytes objects frm and to must be of the same length.
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy._lib.six.callable,_lib.six,callable,"Python Library Documentation: function callable in module scipy._lib.six

callable(obj)
",function,"('(obj)',)",scipy,1.1.0,scipy._lib.six.callable,_lib.six,callable,"Python Library Documentation: function callable in module scipy._lib.six

callable(obj)
",function,"('obj',)","(nan,)","(nan,)","('arg_info',)","('(obj)',)"
scipy,1.1.0,scipy._lib.six.get_unbound_function,_lib.six,get_unbound_function,"Python Library Documentation: function get_unbound_function in module scipy._lib.six

get_unbound_function(unbound)
    Get the function out of a possibly unbound function
",function,"('(unbound)',)",scipy,1.1.0,scipy._lib.six.get_unbound_function,_lib.six,get_unbound_function,"Python Library Documentation: function get_unbound_function in module scipy._lib.six

get_unbound_function(unbound)
    Get the function out of a possibly unbound function
",function,"('unbound',)","(nan,)","(nan,)","('arg_info',)","('(unbound)',)"
scipy,1.1.0,scipy._lib.six.iteritems,_lib.six,iteritems,"Python Library Documentation: function iteritems in module scipy._lib.six

iteritems(d)
    Return an iterator over the (key, value) pairs of a dictionary.
",function,"('(d)',)",scipy,1.1.0,scipy._lib.six.iteritems,_lib.six,iteritems,"Python Library Documentation: function iteritems in module scipy._lib.six

iteritems(d)
    Return an iterator over the (key, value) pairs of a dictionary.
",function,"('d',)","(nan,)","(nan,)","('arg_info',)","('(d)',)"
scipy,1.1.0,scipy._lib.six.iterkeys,_lib.six,iterkeys,"Python Library Documentation: function iterkeys in module scipy._lib.six

iterkeys(d)
    Return an iterator over the keys of a dictionary.
",function,"('(d)',)",scipy,1.1.0,scipy._lib.six.iterkeys,_lib.six,iterkeys,"Python Library Documentation: function iterkeys in module scipy._lib.six

iterkeys(d)
    Return an iterator over the keys of a dictionary.
",function,"('d',)","(nan,)","(nan,)","('arg_info',)","('(d)',)"
scipy,1.1.0,scipy._lib.six.itervalues,_lib.six,itervalues,"Python Library Documentation: function itervalues in module scipy._lib.six

itervalues(d)
    Return an iterator over the values of a dictionary.
",function,"('(d)',)",scipy,1.1.0,scipy._lib.six.itervalues,_lib.six,itervalues,"Python Library Documentation: function itervalues in module scipy._lib.six

itervalues(d)
    Return an iterator over the values of a dictionary.
",function,"('d',)","(nan,)","(nan,)","('arg_info',)","('(d)',)"
scipy,1.1.0,scipy._lib.six.reraise,_lib.six,reraise,"Python Library Documentation: function reraise in module scipy._lib.six

reraise(tp, value, tb=None)
    Reraise an exception.
",function,"('(tp, value, tb=None)',)",scipy,1.1.0,scipy._lib.six.reraise,_lib.six,reraise,"Python Library Documentation: function reraise in module scipy._lib.six

reraise(tp, value, tb=None)
    Reraise an exception.
",function,"('tp', 'value', 'tb')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(tp, value, tb=None)',)"
scipy,1.1.0,scipy._lib.six.text_type,_lib.six,str,"Python Library Documentation: class str in module builtins

class str(object)
 |  str(object='') -> str
 |  str(bytes_or_buffer[, encoding[, errors]]) -> str
 |  
 |  Create a new string object from the given object. If encoding or
 |  errors is specified, then the object must expose a data buffer
 |  that will be decoded using the given encoding and error handler.
 |  Otherwise, returns the result of object.__str__() (if defined)
 |  or repr(object).
 |  encoding defaults to sys.getdefaultencoding().
 |  errors defaults to 'strict'.
 |  
 |  Methods defined here:
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __format__(...)
 |      S.__format__(format_spec) -> str
 |      
 |      Return a formatted version of S as described by format_spec.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __getnewargs__(...)
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.n
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return self*value.
 |  
 |  __sizeof__(...)
 |      S.__sizeof__() -> size of S in memory, in bytes
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  capitalize(...)
 |      S.capitalize() -> str
 |      
 |      Return a capitalized version of S, i.e. make the first character
 |      have upper case and the rest lower case.
 |  
 |  casefold(...)
 |      S.casefold() -> str
 |      
 |      Return a version of S suitable for caseless comparisons.
 |  
 |  center(...)
 |      S.center(width[, fillchar]) -> str
 |      
 |      Return S centered in a string of length width. Padding is
 |      done using the specified fill character (default is a space)
 |  
 |  count(...)
 |      S.count(sub[, start[, end]]) -> int
 |      
 |      Return the number of non-overlapping occurrences of substring sub in
 |      string S[start:end].  Optional arguments start and end are
 |      interpreted as in slice notation.
 |  
 |  encode(...)
 |      S.encode(encoding='utf-8', errors='strict') -> bytes
 |      
 |      Encode S using the codec registered for encoding. Default encoding
 |      is 'utf-8'. errors may be given to set a different error
 |      handling scheme. Default is 'strict' meaning that encoding errors raise
 |      a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
 |      'xmlcharrefreplace' as well as any other name registered with
 |      codecs.register_error that can handle UnicodeEncodeErrors.
 |  
 |  endswith(...)
 |      S.endswith(suffix[, start[, end]]) -> bool
 |      
 |      Return True if S ends with the specified suffix, False otherwise.
 |      With optional start, test S beginning at that position.
 |      With optional end, stop comparing S at that position.
 |      suffix can also be a tuple of strings to try.
 |  
 |  expandtabs(...)
 |      S.expandtabs(tabsize=8) -> str
 |      
 |      Return a copy of S where all tab characters are expanded using spaces.
 |      If tabsize is not given, a tab size of 8 characters is assumed.
 |  
 |  find(...)
 |      S.find(sub[, start[, end]]) -> int
 |      
 |      Return the lowest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Return -1 on failure.
 |  
 |  format(...)
 |      S.format(*args, **kwargs) -> str
 |      
 |      Return a formatted version of S, using substitutions from args and kwargs.
 |      The substitutions are identified by braces ('{' and '}').
 |  
 |  format_map(...)
 |      S.format_map(mapping) -> str
 |      
 |      Return a formatted version of S, using substitutions from mapping.
 |      The substitutions are identified by braces ('{' and '}').
 |  
 |  index(...)
 |      S.index(sub[, start[, end]]) -> int
 |      
 |      Return the lowest index in S where substring sub is found, 
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Raises ValueError when the substring is not found.
 |  
 |  isalnum(...)
 |      S.isalnum() -> bool
 |      
 |      Return True if all characters in S are alphanumeric
 |      and there is at least one character in S, False otherwise.
 |  
 |  isalpha(...)
 |      S.isalpha() -> bool
 |      
 |      Return True if all characters in S are alphabetic
 |      and there is at least one character in S, False otherwise.
 |  
 |  isdecimal(...)
 |      S.isdecimal() -> bool
 |      
 |      Return True if there are only decimal characters in S,
 |      False otherwise.
 |  
 |  isdigit(...)
 |      S.isdigit() -> bool
 |      
 |      Return True if all characters in S are digits
 |      and there is at least one character in S, False otherwise.
 |  
 |  isidentifier(...)
 |      S.isidentifier() -> bool
 |      
 |      Return True if S is a valid identifier according
 |      to the language definition.
 |      
 |      Use keyword.iskeyword() to test for reserved identifiers
 |      such as ""def"" and ""class"".
 |  
 |  islower(...)
 |      S.islower() -> bool
 |      
 |      Return True if all cased characters in S are lowercase and there is
 |      at least one cased character in S, False otherwise.
 |  
 |  isnumeric(...)
 |      S.isnumeric() -> bool
 |      
 |      Return True if there are only numeric characters in S,
 |      False otherwise.
 |  
 |  isprintable(...)
 |      S.isprintable() -> bool
 |      
 |      Return True if all characters in S are considered
 |      printable in repr() or S is empty, False otherwise.
 |  
 |  isspace(...)
 |      S.isspace() -> bool
 |      
 |      Return True if all characters in S are whitespace
 |      and there is at least one character in S, False otherwise.
 |  
 |  istitle(...)
 |      S.istitle() -> bool
 |      
 |      Return True if S is a titlecased string and there is at least one
 |      character in S, i.e. upper- and titlecase characters may only
 |      follow uncased characters and lowercase characters only cased ones.
 |      Return False otherwise.
 |  
 |  isupper(...)
 |      S.isupper() -> bool
 |      
 |      Return True if all cased characters in S are uppercase and there is
 |      at least one cased character in S, False otherwise.
 |  
 |  join(...)
 |      S.join(iterable) -> str
 |      
 |      Return a string which is the concatenation of the strings in the
 |      iterable.  The separator between elements is S.
 |  
 |  ljust(...)
 |      S.ljust(width[, fillchar]) -> str
 |      
 |      Return S left-justified in a Unicode string of length width. Padding is
 |      done using the specified fill character (default is a space).
 |  
 |  lower(...)
 |      S.lower() -> str
 |      
 |      Return a copy of the string S converted to lowercase.
 |  
 |  lstrip(...)
 |      S.lstrip([chars]) -> str
 |      
 |      Return a copy of the string S with leading whitespace removed.
 |      If chars is given and not None, remove characters in chars instead.
 |  
 |  partition(...)
 |      S.partition(sep) -> (head, sep, tail)
 |      
 |      Search for the separator sep in S, and return the part before it,
 |      the separator itself, and the part after it.  If the separator is not
 |      found, return S and two empty strings.
 |  
 |  replace(...)
 |      S.replace(old, new[, count]) -> str
 |      
 |      Return a copy of S with all occurrences of substring
 |      old replaced by new.  If the optional argument count is
 |      given, only the first count occurrences are replaced.
 |  
 |  rfind(...)
 |      S.rfind(sub[, start[, end]]) -> int
 |      
 |      Return the highest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Return -1 on failure.
 |  
 |  rindex(...)
 |      S.rindex(sub[, start[, end]]) -> int
 |      
 |      Return the highest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Raises ValueError when the substring is not found.
 |  
 |  rjust(...)
 |      S.rjust(width[, fillchar]) -> str
 |      
 |      Return S right-justified in a string of length width. Padding is
 |      done using the specified fill character (default is a space).
 |  
 |  rpartition(...)
 |      S.rpartition(sep) -> (head, sep, tail)
 |      
 |      Search for the separator sep in S, starting at the end of S, and return
 |      the part before it, the separator itself, and the part after it.  If the
 |      separator is not found, return two empty strings and S.
 |  
 |  rsplit(...)
 |      S.rsplit(sep=None, maxsplit=-1) -> list of strings
 |      
 |      Return a list of the words in S, using sep as the
 |      delimiter string, starting at the end of the string and
 |      working to the front.  If maxsplit is given, at most maxsplit
 |      splits are done. If sep is not specified, any whitespace string
 |      is a separator.
 |  
 |  rstrip(...)
 |      S.rstrip([chars]) -> str
 |      
 |      Return a copy of the string S with trailing whitespace removed.
 |      If chars is given and not None, remove characters in chars instead.
 |  
 |  split(...)
 |      S.split(sep=None, maxsplit=-1) -> list of strings
 |      
 |      Return a list of the words in S, using sep as the
 |      delimiter string.  If maxsplit is given, at most maxsplit
 |      splits are done. If sep is not specified or is None, any
 |      whitespace string is a separator and empty strings are
 |      removed from the result.
 |  
 |  splitlines(...)
 |      S.splitlines([keepends]) -> list of strings
 |      
 |      Return a list of the lines in S, breaking at line boundaries.
 |      Line breaks are not included in the resulting list unless keepends
 |      is given and true.
 |  
 |  startswith(...)
 |      S.startswith(prefix[, start[, end]]) -> bool
 |      
 |      Return True if S starts with the specified prefix, False otherwise.
 |      With optional start, test S beginning at that position.
 |      With optional end, stop comparing S at that position.
 |      prefix can also be a tuple of strings to try.
 |  
 |  strip(...)
 |      S.strip([chars]) -> str
 |      
 |      Return a copy of the string S with leading and trailing
 |      whitespace removed.
 |      If chars is given and not None, remove characters in chars instead.
 |  
 |  swapcase(...)
 |      S.swapcase() -> str
 |      
 |      Return a copy of S with uppercase characters converted to lowercase
 |      and vice versa.
 |  
 |  title(...)
 |      S.title() -> str
 |      
 |      Return a titlecased version of S, i.e. words start with title case
 |      characters, all remaining cased characters have lower case.
 |  
 |  translate(...)
 |      S.translate(table) -> str
 |      
 |      Return a copy of the string S in which each character has been mapped
 |      through the given translation table. The table must implement
 |      lookup/indexing via __getitem__, for instance a dictionary or list,
 |      mapping Unicode ordinals to Unicode ordinals, strings, or None. If
 |      this operation raises LookupError, the character is left untouched.
 |      Characters mapped to None are deleted.
 |  
 |  upper(...)
 |      S.upper() -> str
 |      
 |      Return a copy of S converted to uppercase.
 |  
 |  zfill(...)
 |      S.zfill(width) -> str
 |      
 |      Pad a numeric string S with zeros on the left, to fill a field
 |      of the specified width. The string S is never truncated.
 |  
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |  
 |  maketrans(x, y=None, z=None, /)
 |      Return a translation table usable for str.translate().
 |      
 |      If there is only one argument, it must be a dictionary mapping Unicode
 |      ordinals (integers) or characters to Unicode ordinals, strings or None.
 |      Character keys will be then converted to ordinals.
 |      If there are two arguments, they must be strings of equal length, and
 |      in the resulting dictionary, each character in x will be mapped to the
 |      character at the same position in y. If there is a third argument, it
 |      must be a string, whose characters will be mapped to None in the result.
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy._lib.six.text_type,_lib.six,str,"Python Library Documentation: class str in module builtins

class str(object)
 |  str(object='') -> str
 |  str(bytes_or_buffer[, encoding[, errors]]) -> str
 |  
 |  Create a new string object from the given object. If encoding or
 |  errors is specified, then the object must expose a data buffer
 |  that will be decoded using the given encoding and error handler.
 |  Otherwise, returns the result of object.__str__() (if defined)
 |  or repr(object).
 |  encoding defaults to sys.getdefaultencoding().
 |  errors defaults to 'strict'.
 |  
 |  Methods defined here:
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __format__(...)
 |      S.__format__(format_spec) -> str
 |      
 |      Return a formatted version of S as described by format_spec.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __getnewargs__(...)
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.n
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return self*value.
 |  
 |  __sizeof__(...)
 |      S.__sizeof__() -> size of S in memory, in bytes
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  capitalize(...)
 |      S.capitalize() -> str
 |      
 |      Return a capitalized version of S, i.e. make the first character
 |      have upper case and the rest lower case.
 |  
 |  casefold(...)
 |      S.casefold() -> str
 |      
 |      Return a version of S suitable for caseless comparisons.
 |  
 |  center(...)
 |      S.center(width[, fillchar]) -> str
 |      
 |      Return S centered in a string of length width. Padding is
 |      done using the specified fill character (default is a space)
 |  
 |  count(...)
 |      S.count(sub[, start[, end]]) -> int
 |      
 |      Return the number of non-overlapping occurrences of substring sub in
 |      string S[start:end].  Optional arguments start and end are
 |      interpreted as in slice notation.
 |  
 |  encode(...)
 |      S.encode(encoding='utf-8', errors='strict') -> bytes
 |      
 |      Encode S using the codec registered for encoding. Default encoding
 |      is 'utf-8'. errors may be given to set a different error
 |      handling scheme. Default is 'strict' meaning that encoding errors raise
 |      a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
 |      'xmlcharrefreplace' as well as any other name registered with
 |      codecs.register_error that can handle UnicodeEncodeErrors.
 |  
 |  endswith(...)
 |      S.endswith(suffix[, start[, end]]) -> bool
 |      
 |      Return True if S ends with the specified suffix, False otherwise.
 |      With optional start, test S beginning at that position.
 |      With optional end, stop comparing S at that position.
 |      suffix can also be a tuple of strings to try.
 |  
 |  expandtabs(...)
 |      S.expandtabs(tabsize=8) -> str
 |      
 |      Return a copy of S where all tab characters are expanded using spaces.
 |      If tabsize is not given, a tab size of 8 characters is assumed.
 |  
 |  find(...)
 |      S.find(sub[, start[, end]]) -> int
 |      
 |      Return the lowest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Return -1 on failure.
 |  
 |  format(...)
 |      S.format(*args, **kwargs) -> str
 |      
 |      Return a formatted version of S, using substitutions from args and kwargs.
 |      The substitutions are identified by braces ('{' and '}').
 |  
 |  format_map(...)
 |      S.format_map(mapping) -> str
 |      
 |      Return a formatted version of S, using substitutions from mapping.
 |      The substitutions are identified by braces ('{' and '}').
 |  
 |  index(...)
 |      S.index(sub[, start[, end]]) -> int
 |      
 |      Return the lowest index in S where substring sub is found, 
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Raises ValueError when the substring is not found.
 |  
 |  isalnum(...)
 |      S.isalnum() -> bool
 |      
 |      Return True if all characters in S are alphanumeric
 |      and there is at least one character in S, False otherwise.
 |  
 |  isalpha(...)
 |      S.isalpha() -> bool
 |      
 |      Return True if all characters in S are alphabetic
 |      and there is at least one character in S, False otherwise.
 |  
 |  isdecimal(...)
 |      S.isdecimal() -> bool
 |      
 |      Return True if there are only decimal characters in S,
 |      False otherwise.
 |  
 |  isdigit(...)
 |      S.isdigit() -> bool
 |      
 |      Return True if all characters in S are digits
 |      and there is at least one character in S, False otherwise.
 |  
 |  isidentifier(...)
 |      S.isidentifier() -> bool
 |      
 |      Return True if S is a valid identifier according
 |      to the language definition.
 |      
 |      Use keyword.iskeyword() to test for reserved identifiers
 |      such as ""def"" and ""class"".
 |  
 |  islower(...)
 |      S.islower() -> bool
 |      
 |      Return True if all cased characters in S are lowercase and there is
 |      at least one cased character in S, False otherwise.
 |  
 |  isnumeric(...)
 |      S.isnumeric() -> bool
 |      
 |      Return True if there are only numeric characters in S,
 |      False otherwise.
 |  
 |  isprintable(...)
 |      S.isprintable() -> bool
 |      
 |      Return True if all characters in S are considered
 |      printable in repr() or S is empty, False otherwise.
 |  
 |  isspace(...)
 |      S.isspace() -> bool
 |      
 |      Return True if all characters in S are whitespace
 |      and there is at least one character in S, False otherwise.
 |  
 |  istitle(...)
 |      S.istitle() -> bool
 |      
 |      Return True if S is a titlecased string and there is at least one
 |      character in S, i.e. upper- and titlecase characters may only
 |      follow uncased characters and lowercase characters only cased ones.
 |      Return False otherwise.
 |  
 |  isupper(...)
 |      S.isupper() -> bool
 |      
 |      Return True if all cased characters in S are uppercase and there is
 |      at least one cased character in S, False otherwise.
 |  
 |  join(...)
 |      S.join(iterable) -> str
 |      
 |      Return a string which is the concatenation of the strings in the
 |      iterable.  The separator between elements is S.
 |  
 |  ljust(...)
 |      S.ljust(width[, fillchar]) -> str
 |      
 |      Return S left-justified in a Unicode string of length width. Padding is
 |      done using the specified fill character (default is a space).
 |  
 |  lower(...)
 |      S.lower() -> str
 |      
 |      Return a copy of the string S converted to lowercase.
 |  
 |  lstrip(...)
 |      S.lstrip([chars]) -> str
 |      
 |      Return a copy of the string S with leading whitespace removed.
 |      If chars is given and not None, remove characters in chars instead.
 |  
 |  partition(...)
 |      S.partition(sep) -> (head, sep, tail)
 |      
 |      Search for the separator sep in S, and return the part before it,
 |      the separator itself, and the part after it.  If the separator is not
 |      found, return S and two empty strings.
 |  
 |  replace(...)
 |      S.replace(old, new[, count]) -> str
 |      
 |      Return a copy of S with all occurrences of substring
 |      old replaced by new.  If the optional argument count is
 |      given, only the first count occurrences are replaced.
 |  
 |  rfind(...)
 |      S.rfind(sub[, start[, end]]) -> int
 |      
 |      Return the highest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Return -1 on failure.
 |  
 |  rindex(...)
 |      S.rindex(sub[, start[, end]]) -> int
 |      
 |      Return the highest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Raises ValueError when the substring is not found.
 |  
 |  rjust(...)
 |      S.rjust(width[, fillchar]) -> str
 |      
 |      Return S right-justified in a string of length width. Padding is
 |      done using the specified fill character (default is a space).
 |  
 |  rpartition(...)
 |      S.rpartition(sep) -> (head, sep, tail)
 |      
 |      Search for the separator sep in S, starting at the end of S, and return
 |      the part before it, the separator itself, and the part after it.  If the
 |      separator is not found, return two empty strings and S.
 |  
 |  rsplit(...)
 |      S.rsplit(sep=None, maxsplit=-1) -> list of strings
 |      
 |      Return a list of the words in S, using sep as the
 |      delimiter string, starting at the end of the string and
 |      working to the front.  If maxsplit is given, at most maxsplit
 |      splits are done. If sep is not specified, any whitespace string
 |      is a separator.
 |  
 |  rstrip(...)
 |      S.rstrip([chars]) -> str
 |      
 |      Return a copy of the string S with trailing whitespace removed.
 |      If chars is given and not None, remove characters in chars instead.
 |  
 |  split(...)
 |      S.split(sep=None, maxsplit=-1) -> list of strings
 |      
 |      Return a list of the words in S, using sep as the
 |      delimiter string.  If maxsplit is given, at most maxsplit
 |      splits are done. If sep is not specified or is None, any
 |      whitespace string is a separator and empty strings are
 |      removed from the result.
 |  
 |  splitlines(...)
 |      S.splitlines([keepends]) -> list of strings
 |      
 |      Return a list of the lines in S, breaking at line boundaries.
 |      Line breaks are not included in the resulting list unless keepends
 |      is given and true.
 |  
 |  startswith(...)
 |      S.startswith(prefix[, start[, end]]) -> bool
 |      
 |      Return True if S starts with the specified prefix, False otherwise.
 |      With optional start, test S beginning at that position.
 |      With optional end, stop comparing S at that position.
 |      prefix can also be a tuple of strings to try.
 |  
 |  strip(...)
 |      S.strip([chars]) -> str
 |      
 |      Return a copy of the string S with leading and trailing
 |      whitespace removed.
 |      If chars is given and not None, remove characters in chars instead.
 |  
 |  swapcase(...)
 |      S.swapcase() -> str
 |      
 |      Return a copy of S with uppercase characters converted to lowercase
 |      and vice versa.
 |  
 |  title(...)
 |      S.title() -> str
 |      
 |      Return a titlecased version of S, i.e. words start with title case
 |      characters, all remaining cased characters have lower case.
 |  
 |  translate(...)
 |      S.translate(table) -> str
 |      
 |      Return a copy of the string S in which each character has been mapped
 |      through the given translation table. The table must implement
 |      lookup/indexing via __getitem__, for instance a dictionary or list,
 |      mapping Unicode ordinals to Unicode ordinals, strings, or None. If
 |      this operation raises LookupError, the character is left untouched.
 |      Characters mapped to None are deleted.
 |  
 |  upper(...)
 |      S.upper() -> str
 |      
 |      Return a copy of S converted to uppercase.
 |  
 |  zfill(...)
 |      S.zfill(width) -> str
 |      
 |      Pad a numeric string S with zeros on the left, to fill a field
 |      of the specified width. The string S is never truncated.
 |  
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |  
 |  maketrans(x, y=None, z=None, /)
 |      Return a translation table usable for str.translate().
 |      
 |      If there is only one argument, it must be a dictionary mapping Unicode
 |      ordinals (integers) or characters to Unicode ordinals, strings or None.
 |      Character keys will be then converted to ordinals.
 |      If there are two arguments, they must be strings of equal length, and
 |      in the resulting dictionary, each character in x will be mapped to the
 |      character at the same position in y. If there is a third argument, it
 |      must be a string, whose characters will be mapped to None in the result.
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy._lib.six.u,_lib.six,u,"Python Library Documentation: function u in module scipy._lib.six

u(s)
    Text literal
",function,"('(s)',)",scipy,1.1.0,scipy._lib.six.u,_lib.six,u,"Python Library Documentation: function u in module scipy._lib.six

u(s)
    Text literal
",function,"('s',)","(nan,)","(nan,)","('arg_info',)","('(s)',)"
scipy,1.1.0,scipy._lib.six.with_metaclass,_lib.six,with_metaclass,"Python Library Documentation: function with_metaclass in module scipy._lib.six

with_metaclass(meta, base=<class 'object'>)
    Create a base class with a metaclass.
",function,"(""(meta, base=<class 'object'>)"",)",scipy,1.1.0,scipy._lib.six.with_metaclass,_lib.six,with_metaclass,"Python Library Documentation: function with_metaclass in module scipy._lib.six

with_metaclass(meta, base=<class 'object'>)
    Create a base class with a metaclass.
",function,"('meta', 'base')","(nan, <class 'object'>)","(nan, 'type')","('arg_info', 'arg_info')","(""(meta, base=<class 'object'>)"",)"
scipy,1.1.0,scipy._lib.six.xrange,_lib.six,range,"Python Library Documentation: class range in module builtins

class range(object)
 |  range(stop) -> range object
 |  range(start, stop[, step]) -> range object
 |  
 |  Return an object that produces a sequence of integers from start (inclusive)
 |  to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.
 |  start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.
 |  These are exactly the valid indices for a list of 4 elements.
 |  When step is given, it specifies the increment (or decrement).
 |  
 |  Methods defined here:
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(...)
 |      Return a reverse iterator.
 |  
 |  count(...)
 |      rangeobject.count(value) -> integer -- return number of occurrences of value
 |  
 |  index(...)
 |      rangeobject.index(value, [start, [stop]]) -> integer -- return index of value.
 |      Raise ValueError if the value is not present.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  start
 |  
 |  step
 |  
 |  stop
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy._lib.six.xrange,_lib.six,range,"Python Library Documentation: class range in module builtins

class range(object)
 |  range(stop) -> range object
 |  range(start, stop[, step]) -> range object
 |  
 |  Return an object that produces a sequence of integers from start (inclusive)
 |  to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.
 |  start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.
 |  These are exactly the valid indices for a list of 4 elements.
 |  When step is given, it specifies the increment (or decrement).
 |  
 |  Methods defined here:
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(...)
 |      Return a reverse iterator.
 |  
 |  count(...)
 |      rangeobject.count(value) -> integer -- return number of occurrences of value
 |  
 |  index(...)
 |      rangeobject.index(value, [start, [stop]]) -> integer -- return index of value.
 |      Raise ValueError if the value is not present.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  start
 |  
 |  step
 |  
 |  stop
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy._lib.six.zip,_lib.six,zip,"Python Library Documentation: class zip in module builtins

class zip(object)
 |  zip(iter1 [,iter2 [...]]) --> zip object
 |  
 |  Return a zip object whose .__next__() method returns a tuple where
 |  the i-th element comes from the i-th iterable argument.  The .__next__()
 |  method continues until the shortest iterable in the argument sequence
 |  is exhausted and then it raises StopIteration.
 |  
 |  Methods defined here:
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __next__(self, /)
 |      Implement next(self).
 |  
 |  __reduce__(...)
 |      Return state information for pickling.
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy._lib.six.zip,_lib.six,zip,"Python Library Documentation: class zip in module builtins

class zip(object)
 |  zip(iter1 [,iter2 [...]]) --> zip object
 |  
 |  Return a zip object whose .__next__() method returns a tuple where
 |  the i-th element comes from the i-th iterable argument.  The .__next__()
 |  method continues until the shortest iterable in the argument sequence
 |  is exhausted and then it raises StopIteration.
 |  
 |  Methods defined here:
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __next__(self, /)
 |      Implement next(self).
 |  
 |  __reduce__(...)
 |      Return state information for pickling.
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.cluster._hierarchy.Heap,cluster._hierarchy,Heap,"Python Library Documentation: class Heap in module scipy.cluster._hierarchy

class Heap(builtins.object)
 |  Binary heap.
 |  
 |  Heap stores values and keys. Values are passed explicitly, whereas keys
 |  are assigned implicitly to natural numbers (from 0 to n - 1).
 |  
 |  The supported operations (all have O(log n) time complexity):
 |  
 |      * Return the current minimum value and the corresponding key.
 |      * Remove the current minimum value.
 |      * Change the value of the given key. Note that the key must be still
 |        in the heap.
 |  
 |  The heap is stored as an array, where children of parent i have indices
 |  2 * i + 1 and 2 * i + 2. All public methods are based on  `sift_down` and
 |  `sift_up` methods, which restore the heap property by moving an element
 |  down or up in the heap.
 |  
 |  Methods defined here:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__ = __reduce_cython__(...)
 |  
 |  __setstate__ = __setstate_cython__(...)
 |  
 |  change_value(...)
 |  
 |  get_min(...)
 |  
 |  remove_min(...)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __pyx_vtable__ = <capsule object NULL>
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.cluster._hierarchy.Heap,cluster._hierarchy,Heap,"Python Library Documentation: class Heap in module scipy.cluster._hierarchy

class Heap(builtins.object)
 |  Binary heap.
 |  
 |  Heap stores values and keys. Values are passed explicitly, whereas keys
 |  are assigned implicitly to natural numbers (from 0 to n - 1).
 |  
 |  The supported operations (all have O(log n) time complexity):
 |  
 |      * Return the current minimum value and the corresponding key.
 |      * Remove the current minimum value.
 |      * Change the value of the given key. Note that the key must be still
 |        in the heap.
 |  
 |  The heap is stored as an array, where children of parent i have indices
 |  2 * i + 1 and 2 * i + 2. All public methods are based on  `sift_down` and
 |  `sift_up` methods, which restore the heap property by moving an element
 |  down or up in the heap.
 |  
 |  Methods defined here:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__ = __reduce_cython__(...)
 |  
 |  __setstate__ = __setstate_cython__(...)
 |  
 |  change_value(...)
 |  
 |  get_min(...)
 |  
 |  remove_min(...)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __pyx_vtable__ = <capsule object NULL>
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.cluster._hierarchy.LinkageUnionFind,cluster._hierarchy,LinkageUnionFind,"Python Library Documentation: class LinkageUnionFind in module scipy.cluster._hierarchy

class LinkageUnionFind(builtins.object)
 |  Structure for fast cluster labeling in unsorted dendrogram.
 |  
 |  Methods defined here:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__ = __reduce_cython__(...)
 |  
 |  __setstate__ = __setstate_cython__(...)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __pyx_vtable__ = <capsule object NULL>
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.cluster._hierarchy.LinkageUnionFind,cluster._hierarchy,LinkageUnionFind,"Python Library Documentation: class LinkageUnionFind in module scipy.cluster._hierarchy

class LinkageUnionFind(builtins.object)
 |  Structure for fast cluster labeling in unsorted dendrogram.
 |  
 |  Methods defined here:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__ = __reduce_cython__(...)
 |  
 |  __setstate__ = __setstate_cython__(...)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __pyx_vtable__ = <capsule object NULL>
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.cluster._optimal_leaf_ordering.is_valid_dm,cluster._optimal_leaf_ordering,is_valid_dm,"Python Library Documentation: function is_valid_dm in module scipy.spatial.distance

is_valid_dm(D, tol=0.0, throw=False, name='D', warning=False)
    Return True if input array is a valid distance matrix.
    
    Distance matrices must be 2-dimensional numpy arrays.
    They must have a zero-diagonal, and they must be symmetric.
    
    Parameters
    ----------
    D : ndarray
        The candidate object to test for validity.
    tol : float, optional
        The distance matrix should be symmetric. `tol` is the maximum
        difference between entries ``ij`` and ``ji`` for the distance
        metric to be considered symmetric.
    throw : bool, optional
        An exception is thrown if the distance matrix passed is not valid.
    name : str, optional
        The name of the variable to checked. This is useful if
        throw is set to True so the offending variable can be identified
        in the exception message when an exception is thrown.
    warning : bool, optional
        Instead of throwing an exception, a warning message is
        raised.
    
    Returns
    -------
    valid : bool
        True if the variable `D` passed is a valid distance matrix.
    
    Notes
    -----
    Small numerical differences in `D` and `D.T` and non-zeroness of
    the diagonal are ignored if they are within the tolerance specified
    by `tol`.
",function,"(""(D, tol=0.0, throw=False, name='D', warning=False)"",)",scipy,1.1.0,scipy.cluster._optimal_leaf_ordering.is_valid_dm,cluster._optimal_leaf_ordering,is_valid_dm,"Python Library Documentation: function is_valid_dm in module scipy.spatial.distance

is_valid_dm(D, tol=0.0, throw=False, name='D', warning=False)
    Return True if input array is a valid distance matrix.
    
    Distance matrices must be 2-dimensional numpy arrays.
    They must have a zero-diagonal, and they must be symmetric.
    
    Parameters
    ----------
    D : ndarray
        The candidate object to test for validity.
    tol : float, optional
        The distance matrix should be symmetric. `tol` is the maximum
        difference between entries ``ij`` and ``ji`` for the distance
        metric to be considered symmetric.
    throw : bool, optional
        An exception is thrown if the distance matrix passed is not valid.
    name : str, optional
        The name of the variable to checked. This is useful if
        throw is set to True so the offending variable can be identified
        in the exception message when an exception is thrown.
    warning : bool, optional
        Instead of throwing an exception, a warning message is
        raised.
    
    Returns
    -------
    valid : bool
        True if the variable `D` passed is a valid distance matrix.
    
    Notes
    -----
    Small numerical differences in `D` and `D.T` and non-zeroness of
    the diagonal are ignored if they are within the tolerance specified
    by `tol`.
",function,"('D', 'tol', 'throw', 'name', 'warning')","(nan, 0.0, False, 'D', False)","(nan, 'float', 'bool', 'str', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(D, tol=0.0, throw=False, name='D', warning=False)"",)"
scipy,1.1.0,scipy.cluster._optimal_leaf_ordering.is_valid_y,cluster._optimal_leaf_ordering,is_valid_y,"Python Library Documentation: function is_valid_y in module scipy.spatial.distance

is_valid_y(y, warning=False, throw=False, name=None)
    Return True if the input array is a valid condensed distance matrix.
    
    Condensed distance matrices must be 1-dimensional numpy arrays.
    Their length must be a binomial coefficient :math:`{n \choose 2}`
    for some positive integer n.
    
    Parameters
    ----------
    y : ndarray
        The condensed distance matrix.
    warning : bool, optional
        Invokes a warning if the variable passed is not a valid
        condensed distance matrix. The warning message explains why
        the distance matrix is not valid.  `name` is used when
        referencing the offending variable.
    throw : bool, optional
        Throws an exception if the variable passed is not a valid
        condensed distance matrix.
    name : bool, optional
        Used when referencing the offending variable in the
        warning or exception message.
",function,"('(y, warning=False, throw=False, name=None)',)",scipy,1.1.0,scipy.cluster._optimal_leaf_ordering.is_valid_y,cluster._optimal_leaf_ordering,is_valid_y,"Python Library Documentation: function is_valid_y in module scipy.spatial.distance

is_valid_y(y, warning=False, throw=False, name=None)
    Return True if the input array is a valid condensed distance matrix.
    
    Condensed distance matrices must be 1-dimensional numpy arrays.
    Their length must be a binomial coefficient :math:`{n \choose 2}`
    for some positive integer n.
    
    Parameters
    ----------
    y : ndarray
        The condensed distance matrix.
    warning : bool, optional
        Invokes a warning if the variable passed is not a valid
        condensed distance matrix. The warning message explains why
        the distance matrix is not valid.  `name` is used when
        referencing the offending variable.
    throw : bool, optional
        Throws an exception if the variable passed is not a valid
        condensed distance matrix.
    name : bool, optional
        Used when referencing the offending variable in the
        warning or exception message.
",function,"('y', 'warning', 'throw', 'name')","(nan, False, False, None)","(nan, 'bool', 'bool', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(y, warning=False, throw=False, name=None)',)"
scipy,1.1.0,scipy.cluster._optimal_leaf_ordering.squareform,cluster._optimal_leaf_ordering,squareform,"Python Library Documentation: function squareform in module scipy.spatial.distance

squareform(X, force='no', checks=True)
    Convert a vector-form distance vector to a square-form distance
    matrix, and vice-versa.
    
    Parameters
    ----------
    X : ndarray
        Either a condensed or redundant distance matrix.
    force : str, optional
        As with MATLAB(TM), if force is equal to ``'tovector'`` or
        ``'tomatrix'``, the input will be treated as a distance matrix or
        distance vector respectively.
    checks : bool, optional
        If set to False, no checks will be made for matrix
        symmetry nor zero diagonals. This is useful if it is known that
        ``X - X.T1`` is small and ``diag(X)`` is close to zero.
        These values are ignored any way so they do not disrupt the
        squareform transformation.
    
    Returns
    -------
    Y : ndarray
        If a condensed distance matrix is passed, a redundant one is
        returned, or if a redundant one is passed, a condensed distance
        matrix is returned.
    
    Notes
    -----
    1. v = squareform(X)
    
       Given a square d-by-d symmetric distance matrix X,
       ``v = squareform(X)`` returns a ``d * (d-1) / 2`` (or
       :math:`{n \choose 2}`) sized vector v.
    
      :math:`v[{n \choose 2}-{n-i \choose 2} + (j-i-1)]` is the distance
      between points i and j. If X is non-square or asymmetric, an error
      is returned.
    
    2. X = squareform(v)
    
      Given a ``d*(d-1)/2`` sized v for some integer ``d >= 2`` encoding
      distances as described, ``X = squareform(v)`` returns a d by d distance
      matrix X.  The ``X[i, j]`` and ``X[j, i]`` values are set to
      :math:`v[{n \choose 2}-{n-i \choose 2} + (j-i-1)]` and all
      diagonal elements are zero.
    
    In Scipy 0.19.0, ``squareform`` stopped casting all input types to
    float64, and started returning arrays of the same dtype as the input.
",function,"(""(X, force='no', checks=True)"",)",scipy,1.1.0,scipy.cluster._optimal_leaf_ordering.squareform,cluster._optimal_leaf_ordering,squareform,"Python Library Documentation: function squareform in module scipy.spatial.distance

squareform(X, force='no', checks=True)
    Convert a vector-form distance vector to a square-form distance
    matrix, and vice-versa.
    
    Parameters
    ----------
    X : ndarray
        Either a condensed or redundant distance matrix.
    force : str, optional
        As with MATLAB(TM), if force is equal to ``'tovector'`` or
        ``'tomatrix'``, the input will be treated as a distance matrix or
        distance vector respectively.
    checks : bool, optional
        If set to False, no checks will be made for matrix
        symmetry nor zero diagonals. This is useful if it is known that
        ``X - X.T1`` is small and ``diag(X)`` is close to zero.
        These values are ignored any way so they do not disrupt the
        squareform transformation.
    
    Returns
    -------
    Y : ndarray
        If a condensed distance matrix is passed, a redundant one is
        returned, or if a redundant one is passed, a condensed distance
        matrix is returned.
    
    Notes
    -----
    1. v = squareform(X)
    
       Given a square d-by-d symmetric distance matrix X,
       ``v = squareform(X)`` returns a ``d * (d-1) / 2`` (or
       :math:`{n \choose 2}`) sized vector v.
    
      :math:`v[{n \choose 2}-{n-i \choose 2} + (j-i-1)]` is the distance
      between points i and j. If X is non-square or asymmetric, an error
      is returned.
    
    2. X = squareform(v)
    
      Given a ``d*(d-1)/2`` sized v for some integer ``d >= 2`` encoding
      distances as described, ``X = squareform(v)`` returns a d by d distance
      matrix X.  The ``X[i, j]`` and ``X[j, i]`` values are set to
      :math:`v[{n \choose 2}-{n-i \choose 2} + (j-i-1)]` and all
      diagonal elements are zero.
    
    In Scipy 0.19.0, ``squareform`` stopped casting all input types to
    float64, and started returning arrays of the same dtype as the input.
",function,"('X', 'force', 'checks')","(nan, 'no', True)","(nan, 'str', 'bool')","('arg_info', 'arg_info', 'arg_info')","(""(X, force='no', checks=True)"",)"
scipy,1.1.0,scipy.cluster.hierarchy.ClusterNode,cluster.hierarchy,ClusterNode,"Python Library Documentation: class ClusterNode in module scipy.cluster.hierarchy

class ClusterNode(builtins.object)
 |  A tree node class for representing a cluster.
 |  
 |  Leaf nodes correspond to original observations, while non-leaf nodes
 |  correspond to non-singleton clusters.
 |  
 |  The `to_tree` function converts a matrix returned by the linkage
 |  function into an easy-to-use tree representation.
 |  
 |  All parameter names are also attributes.
 |  
 |  Parameters
 |  ----------
 |  id : int
 |      The node id.
 |  left : ClusterNode instance, optional
 |      The left child tree node.
 |  right : ClusterNode instance, optional
 |      The right child tree node.
 |  dist : float, optional
 |      Distance for this cluster in the linkage matrix.
 |  count : int, optional
 |      The number of samples in this cluster.
 |  
 |  See Also
 |  --------
 |  to_tree : for converting a linkage matrix ``Z`` into a tree object.
 |  
 |  Methods defined here:
 |  
 |  __eq__(self, node)
 |      Return self==value.
 |  
 |  __gt__(self, node)
 |      Return self>value.
 |  
 |  __init__(self, id, left=None, right=None, dist=0, count=1)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __lt__(self, node)
 |      Return self<value.
 |  
 |  get_count(self)
 |      The number of leaf nodes (original observations) belonging to
 |      the cluster node nd. If the target node is a leaf, 1 is
 |      returned.
 |      
 |      Returns
 |      -------
 |      get_count : int
 |          The number of leaf nodes below the target node.
 |  
 |  get_id(self)
 |      The identifier of the target node.
 |      
 |      For ``0 <= i < n``, `i` corresponds to original observation i.
 |      For ``n <= i < 2n-1``, `i` corresponds to non-singleton cluster formed
 |      at iteration ``i-n``.
 |      
 |      Returns
 |      -------
 |      id : int
 |          The identifier of the target node.
 |  
 |  get_left(self)
 |      Return a reference to the left child tree object.
 |      
 |      Returns
 |      -------
 |      left : ClusterNode
 |          The left child of the target node.  If the node is a leaf,
 |          None is returned.
 |  
 |  get_right(self)
 |      Return a reference to the right child tree object.
 |      
 |      Returns
 |      -------
 |      right : ClusterNode
 |          The left child of the target node.  If the node is a leaf,
 |          None is returned.
 |  
 |  is_leaf(self)
 |      Return True if the target node is a leaf.
 |      
 |      Returns
 |      -------
 |      leafness : bool
 |          True if the target node is a leaf node.
 |  
 |  pre_order(self, func=<function ClusterNode.<lambda> at 0x000000000619A2F0>)
 |      Perform pre-order traversal without recursive function calls.
 |      
 |      When a leaf node is first encountered, ``func`` is called with
 |      the leaf node as its argument, and its result is appended to
 |      the list.
 |      
 |      For example, the statement::
 |      
 |         ids = root.pre_order(lambda x: x.id)
 |      
 |      returns a list of the node ids corresponding to the leaf nodes
 |      of the tree as they appear from left to right.
 |      
 |      Parameters
 |      ----------
 |      func : function
 |          Applied to each leaf ClusterNode object in the pre-order traversal.
 |          Given the ``i``-th leaf node in the pre-order traversal ``n[i]``,
 |          the result of ``func(n[i])`` is stored in ``L[i]``. If not
 |          provided, the index of the original observation to which the node
 |          corresponds is used.
 |      
 |      Returns
 |      -------
 |      L : list
 |          The pre-order traversal.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None
",class,"('(self, id, left=None, right=None, dist=0, count=1)',)",scipy,1.1.0,scipy.cluster.hierarchy.ClusterNode,cluster.hierarchy,ClusterNode,"Python Library Documentation: class ClusterNode in module scipy.cluster.hierarchy

class ClusterNode(builtins.object)
 |  A tree node class for representing a cluster.
 |  
 |  Leaf nodes correspond to original observations, while non-leaf nodes
 |  correspond to non-singleton clusters.
 |  
 |  The `to_tree` function converts a matrix returned by the linkage
 |  function into an easy-to-use tree representation.
 |  
 |  All parameter names are also attributes.
 |  
 |  Parameters
 |  ----------
 |  id : int
 |      The node id.
 |  left : ClusterNode instance, optional
 |      The left child tree node.
 |  right : ClusterNode instance, optional
 |      The right child tree node.
 |  dist : float, optional
 |      Distance for this cluster in the linkage matrix.
 |  count : int, optional
 |      The number of samples in this cluster.
 |  
 |  See Also
 |  --------
 |  to_tree : for converting a linkage matrix ``Z`` into a tree object.
 |  
 |  Methods defined here:
 |  
 |  __eq__(self, node)
 |      Return self==value.
 |  
 |  __gt__(self, node)
 |      Return self>value.
 |  
 |  __init__(self, id, left=None, right=None, dist=0, count=1)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __lt__(self, node)
 |      Return self<value.
 |  
 |  get_count(self)
 |      The number of leaf nodes (original observations) belonging to
 |      the cluster node nd. If the target node is a leaf, 1 is
 |      returned.
 |      
 |      Returns
 |      -------
 |      get_count : int
 |          The number of leaf nodes below the target node.
 |  
 |  get_id(self)
 |      The identifier of the target node.
 |      
 |      For ``0 <= i < n``, `i` corresponds to original observation i.
 |      For ``n <= i < 2n-1``, `i` corresponds to non-singleton cluster formed
 |      at iteration ``i-n``.
 |      
 |      Returns
 |      -------
 |      id : int
 |          The identifier of the target node.
 |  
 |  get_left(self)
 |      Return a reference to the left child tree object.
 |      
 |      Returns
 |      -------
 |      left : ClusterNode
 |          The left child of the target node.  If the node is a leaf,
 |          None is returned.
 |  
 |  get_right(self)
 |      Return a reference to the right child tree object.
 |      
 |      Returns
 |      -------
 |      right : ClusterNode
 |          The left child of the target node.  If the node is a leaf,
 |          None is returned.
 |  
 |  is_leaf(self)
 |      Return True if the target node is a leaf.
 |      
 |      Returns
 |      -------
 |      leafness : bool
 |          True if the target node is a leaf node.
 |  
 |  pre_order(self, func=<function ClusterNode.<lambda> at 0x000000000619A2F0>)
 |      Perform pre-order traversal without recursive function calls.
 |      
 |      When a leaf node is first encountered, ``func`` is called with
 |      the leaf node as its argument, and its result is appended to
 |      the list.
 |      
 |      For example, the statement::
 |      
 |         ids = root.pre_order(lambda x: x.id)
 |      
 |      returns a list of the node ids corresponding to the leaf nodes
 |      of the tree as they appear from left to right.
 |      
 |      Parameters
 |      ----------
 |      func : function
 |          Applied to each leaf ClusterNode object in the pre-order traversal.
 |          Given the ``i``-th leaf node in the pre-order traversal ``n[i]``,
 |          the result of ``func(n[i])`` is stored in ``L[i]``. If not
 |          provided, the index of the original observation to which the node
 |          corresponds is used.
 |      
 |      Returns
 |      -------
 |      L : list
 |          The pre-order traversal.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None
",class,"('self', 'id', 'left', 'right', 'dist', 'count')","(nan, nan, None, None, 0, 1)","(nan, nan, 'NoneType', 'NoneType', 'int', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, id, left=None, right=None, dist=0, count=1)',)"
scipy,1.1.0,scipy.cluster.hierarchy.ClusterWarning,cluster.hierarchy,ClusterWarning,"Python Library Documentation: class ClusterWarning in module scipy.cluster.hierarchy

class ClusterWarning(builtins.UserWarning)
 |  Base class for warnings generated by user code.
 |  
 |  Method resolution order:
 |      ClusterWarning
 |      builtins.UserWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.UserWarning:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.cluster.hierarchy.ClusterWarning,cluster.hierarchy,ClusterWarning,"Python Library Documentation: class ClusterWarning in module scipy.cluster.hierarchy

class ClusterWarning(builtins.UserWarning)
 |  Base class for warnings generated by user code.
 |  
 |  Method resolution order:
 |      ClusterWarning
 |      builtins.UserWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.UserWarning:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.cluster.hierarchy._append_contraction_marks,cluster.hierarchy,_append_contraction_marks,"Python Library Documentation: function _append_contraction_marks in module scipy.cluster.hierarchy

_append_contraction_marks(Z, iv, i, n, contraction_marks)
",function,"('(Z, iv, i, n, contraction_marks)',)",scipy,1.1.0,scipy.cluster.hierarchy._append_contraction_marks,cluster.hierarchy,_append_contraction_marks,"Python Library Documentation: function _append_contraction_marks in module scipy.cluster.hierarchy

_append_contraction_marks(Z, iv, i, n, contraction_marks)
",function,"('Z', 'iv', 'i', 'n', 'contraction_marks')","(nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(Z, iv, i, n, contraction_marks)',)"
scipy,1.1.0,scipy.cluster.hierarchy._append_contraction_marks_sub,cluster.hierarchy,_append_contraction_marks_sub,"Python Library Documentation: function _append_contraction_marks_sub in module scipy.cluster.hierarchy

_append_contraction_marks_sub(Z, iv, i, n, contraction_marks)
",function,"('(Z, iv, i, n, contraction_marks)',)",scipy,1.1.0,scipy.cluster.hierarchy._append_contraction_marks_sub,cluster.hierarchy,_append_contraction_marks_sub,"Python Library Documentation: function _append_contraction_marks_sub in module scipy.cluster.hierarchy

_append_contraction_marks_sub(Z, iv, i, n, contraction_marks)
",function,"('Z', 'iv', 'i', 'n', 'contraction_marks')","(nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(Z, iv, i, n, contraction_marks)',)"
scipy,1.1.0,scipy.cluster.hierarchy._append_nonsingleton_leaf_node,cluster.hierarchy,_append_nonsingleton_leaf_node,"Python Library Documentation: function _append_nonsingleton_leaf_node in module scipy.cluster.hierarchy

_append_nonsingleton_leaf_node(Z, p, n, level, lvs, ivl, leaf_label_func, i, labels, show_leaf_counts)
",function,"('(Z, p, n, level, lvs, ivl, leaf_label_func, i, labels, show_leaf_counts)',)",scipy,1.1.0,scipy.cluster.hierarchy._append_nonsingleton_leaf_node,cluster.hierarchy,_append_nonsingleton_leaf_node,"Python Library Documentation: function _append_nonsingleton_leaf_node in module scipy.cluster.hierarchy

_append_nonsingleton_leaf_node(Z, p, n, level, lvs, ivl, leaf_label_func, i, labels, show_leaf_counts)
",function,"('Z', 'p', 'n', 'level', 'lvs', 'ivl', 'leaf_label_func', 'i', 'labels', 'show_leaf_counts')","(nan, nan, nan, nan, nan, nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan, nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(Z, p, n, level, lvs, ivl, leaf_label_func, i, labels, show_leaf_counts)',)"
scipy,1.1.0,scipy.cluster.hierarchy._append_singleton_leaf_node,cluster.hierarchy,_append_singleton_leaf_node,"Python Library Documentation: function _append_singleton_leaf_node in module scipy.cluster.hierarchy

_append_singleton_leaf_node(Z, p, n, level, lvs, ivl, leaf_label_func, i, labels)
",function,"('(Z, p, n, level, lvs, ivl, leaf_label_func, i, labels)',)",scipy,1.1.0,scipy.cluster.hierarchy._append_singleton_leaf_node,cluster.hierarchy,_append_singleton_leaf_node,"Python Library Documentation: function _append_singleton_leaf_node in module scipy.cluster.hierarchy

_append_singleton_leaf_node(Z, p, n, level, lvs, ivl, leaf_label_func, i, labels)
",function,"('Z', 'p', 'n', 'level', 'lvs', 'ivl', 'leaf_label_func', 'i', 'labels')","(nan, nan, nan, nan, nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(Z, p, n, level, lvs, ivl, leaf_label_func, i, labels)',)"
scipy,1.1.0,scipy.cluster.hierarchy._check_hierarchy_not_all_clusters_used,cluster.hierarchy,_check_hierarchy_not_all_clusters_used,"Python Library Documentation: function _check_hierarchy_not_all_clusters_used in module scipy.cluster.hierarchy

_check_hierarchy_not_all_clusters_used(Z)
",function,"('(Z)',)",scipy,1.1.0,scipy.cluster.hierarchy._check_hierarchy_not_all_clusters_used,cluster.hierarchy,_check_hierarchy_not_all_clusters_used,"Python Library Documentation: function _check_hierarchy_not_all_clusters_used in module scipy.cluster.hierarchy

_check_hierarchy_not_all_clusters_used(Z)
",function,"('Z',)","(nan,)","(nan,)","('arg_info',)","('(Z)',)"
scipy,1.1.0,scipy.cluster.hierarchy._check_hierarchy_uses_cluster_before_formed,cluster.hierarchy,_check_hierarchy_uses_cluster_before_formed,"Python Library Documentation: function _check_hierarchy_uses_cluster_before_formed in module scipy.cluster.hierarchy

_check_hierarchy_uses_cluster_before_formed(Z)
",function,"('(Z)',)",scipy,1.1.0,scipy.cluster.hierarchy._check_hierarchy_uses_cluster_before_formed,cluster.hierarchy,_check_hierarchy_uses_cluster_before_formed,"Python Library Documentation: function _check_hierarchy_uses_cluster_before_formed in module scipy.cluster.hierarchy

_check_hierarchy_uses_cluster_before_formed(Z)
",function,"('Z',)","(nan,)","(nan,)","('arg_info',)","('(Z)',)"
scipy,1.1.0,scipy.cluster.hierarchy._check_hierarchy_uses_cluster_more_than_once,cluster.hierarchy,_check_hierarchy_uses_cluster_more_than_once,"Python Library Documentation: function _check_hierarchy_uses_cluster_more_than_once in module scipy.cluster.hierarchy

_check_hierarchy_uses_cluster_more_than_once(Z)
",function,"('(Z)',)",scipy,1.1.0,scipy.cluster.hierarchy._check_hierarchy_uses_cluster_more_than_once,cluster.hierarchy,_check_hierarchy_uses_cluster_more_than_once,"Python Library Documentation: function _check_hierarchy_uses_cluster_more_than_once in module scipy.cluster.hierarchy

_check_hierarchy_uses_cluster_more_than_once(Z)
",function,"('Z',)","(nan,)","(nan,)","('arg_info',)","('(Z)',)"
scipy,1.1.0,scipy.cluster.hierarchy._cnode_type,cluster.hierarchy,type,"Python Library Documentation: class type in module builtins

class type(object)
 |  type(object_or_name, bases, dict)
 |  type(object) -> the object's type
 |  type(name, bases, dict) -> a new type
 |  
 |  Methods defined here:
 |  
 |  __call__(self, /, *args, **kwargs)
 |      Call self as a function.
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __dir__(...)
 |      __dir__() -> list
 |      specialized __dir__ implementation for types
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __instancecheck__(...)
 |      __instancecheck__() -> bool
 |      check if an object is an instance
 |  
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __prepare__(...)
 |      __prepare__() -> dict
 |      used to create the namespace for the class statement
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      return memory consumption of the type object
 |  
 |  __subclasscheck__(...)
 |      __subclasscheck__() -> bool
 |      check if a class is a subclass
 |  
 |  __subclasses__(...)
 |      __subclasses__() -> list of immediate subclasses
 |  
 |  mro(...)
 |      mro() -> list
 |      return a type's method resolution order
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __abstractmethods__
 |  
 |  __dict__
 |  
 |  __text_signature__
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __base__ = <class 'object'>
 |      The most base type
 |  
 |  __bases__ = (<class 'object'>,)
 |  
 |  __basicsize__ = 864
 |  
 |  __dictoffset__ = 264
 |  
 |  __flags__ = -2146675712
 |  
 |  __itemsize__ = 40
 |  
 |  __mro__ = (<class 'type'>, <class 'object'>)
 |  
 |  __weakrefoffset__ = 368
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.cluster.hierarchy._cnode_type,cluster.hierarchy,type,"Python Library Documentation: class type in module builtins

class type(object)
 |  type(object_or_name, bases, dict)
 |  type(object) -> the object's type
 |  type(name, bases, dict) -> a new type
 |  
 |  Methods defined here:
 |  
 |  __call__(self, /, *args, **kwargs)
 |      Call self as a function.
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __dir__(...)
 |      __dir__() -> list
 |      specialized __dir__ implementation for types
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __instancecheck__(...)
 |      __instancecheck__() -> bool
 |      check if an object is an instance
 |  
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __prepare__(...)
 |      __prepare__() -> dict
 |      used to create the namespace for the class statement
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      return memory consumption of the type object
 |  
 |  __subclasscheck__(...)
 |      __subclasscheck__() -> bool
 |      check if a class is a subclass
 |  
 |  __subclasses__(...)
 |      __subclasses__() -> list of immediate subclasses
 |  
 |  mro(...)
 |      mro() -> list
 |      return a type's method resolution order
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __abstractmethods__
 |  
 |  __dict__
 |  
 |  __text_signature__
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __base__ = <class 'object'>
 |      The most base type
 |  
 |  __bases__ = (<class 'object'>,)
 |  
 |  __basicsize__ = 864
 |  
 |  __dictoffset__ = 264
 |  
 |  __flags__ = -2146675712
 |  
 |  __itemsize__ = 40
 |  
 |  __mro__ = (<class 'type'>, <class 'object'>)
 |  
 |  __weakrefoffset__ = 368
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.cluster.hierarchy._convert_to_bool,cluster.hierarchy,_convert_to_bool,"Python Library Documentation: function _convert_to_bool in module scipy.cluster.hierarchy

_convert_to_bool(X)
",function,"('(X)',)",scipy,1.1.0,scipy.cluster.hierarchy._convert_to_bool,cluster.hierarchy,_convert_to_bool,"Python Library Documentation: function _convert_to_bool in module scipy.cluster.hierarchy

_convert_to_bool(X)
",function,"('X',)","(nan,)","(nan,)","('arg_info',)","('(X)',)"
scipy,1.1.0,scipy.cluster.hierarchy._convert_to_double,cluster.hierarchy,_convert_to_double,"Python Library Documentation: function _convert_to_double in module scipy.cluster.hierarchy

_convert_to_double(X)
",function,"('(X)',)",scipy,1.1.0,scipy.cluster.hierarchy._convert_to_double,cluster.hierarchy,_convert_to_double,"Python Library Documentation: function _convert_to_double in module scipy.cluster.hierarchy

_convert_to_double(X)
",function,"('X',)","(nan,)","(nan,)","('arg_info',)","('(X)',)"
scipy,1.1.0,scipy.cluster.hierarchy._copy_array_if_base_present,cluster.hierarchy,_copy_array_if_base_present,"Python Library Documentation: function _copy_array_if_base_present in module scipy.cluster.hierarchy

_copy_array_if_base_present(a)
    Copy the array if its base points to a parent array.
",function,"('(a)',)",scipy,1.1.0,scipy.cluster.hierarchy._copy_array_if_base_present,cluster.hierarchy,_copy_array_if_base_present,"Python Library Documentation: function _copy_array_if_base_present in module scipy.cluster.hierarchy

_copy_array_if_base_present(a)
    Copy the array if its base points to a parent array.
",function,"('a',)","(nan,)","(nan,)","('arg_info',)","('(a)',)"
scipy,1.1.0,scipy.cluster.hierarchy._copy_arrays_if_base_present,cluster.hierarchy,_copy_arrays_if_base_present,"Python Library Documentation: function _copy_arrays_if_base_present in module scipy.cluster.hierarchy

_copy_arrays_if_base_present(T)
    Accept a tuple of arrays T. Copies the array T[i] if its base array
    points to an actual array. Otherwise, the reference is just copied.
    This is useful if the arrays are being passed to a C function that
    does not do proper striding.
",function,"('(T)',)",scipy,1.1.0,scipy.cluster.hierarchy._copy_arrays_if_base_present,cluster.hierarchy,_copy_arrays_if_base_present,"Python Library Documentation: function _copy_arrays_if_base_present in module scipy.cluster.hierarchy

_copy_arrays_if_base_present(T)
    Accept a tuple of arrays T. Copies the array T[i] if its base array
    points to an actual array. Otherwise, the reference is just copied.
    This is useful if the arrays are being passed to a C function that
    does not do proper striding.
",function,"('T',)","(nan,)","(nan,)","('arg_info',)","('(T)',)"
scipy,1.1.0,scipy.cluster.hierarchy._dendrogram_calculate_info,cluster.hierarchy,_dendrogram_calculate_info,"Python Library Documentation: function _dendrogram_calculate_info in module scipy.cluster.hierarchy

_dendrogram_calculate_info(Z, p, truncate_mode, color_threshold=inf, get_leaves=True, orientation='top', labels=None, count_sort=False, distance_sort=False, show_leaf_counts=False, i=-1, iv=0.0, ivl=[], n=0, icoord_list=[], dcoord_list=[], lvs=None, mhr=False, current_color=[], color_list=[], currently_below_threshold=[], leaf_label_func=None, level=0, contraction_marks=None, link_color_func=None, above_threshold_color='b')
    Calculate the endpoints of the links as well as the labels for the
    the dendrogram rooted at the node with index i. iv is the independent
    variable value to plot the left-most leaf node below the root node i
    (if orientation='top', this would be the left-most x value where the
    plotting of this root node i and its descendents should begin).
    
    ivl is a list to store the labels of the leaf nodes. The leaf_label_func
    is called whenever ivl != None, labels == None, and
    leaf_label_func != None. When ivl != None and labels != None, the
    labels list is used only for labeling the leaf nodes. When
    ivl == None, no labels are generated for leaf nodes.
    
    When get_leaves==True, a list of leaves is built as they are visited
    in the dendrogram.
    
    Returns a tuple with l being the independent variable coordinate that
    corresponds to the midpoint of cluster to the left of cluster i if
    i is non-singleton, otherwise the independent coordinate of the leaf
    node if i is a leaf node.
    
    Returns
    -------
    A tuple (left, w, h, md), where:
    
      * left is the independent variable coordinate of the center of the
        the U of the subtree
    
      * w is the amount of space used for the subtree (in independent
        variable units)
    
      * h is the height of the subtree in dependent variable units
    
      * md is the ``max(Z[*,2]``) for all nodes ``*`` below and including
        the target node.
",function,"(""(Z, p, truncate_mode, color_threshold=inf, get_leaves=True, orientation='top', labels=None, count_sort=False, distance_sort=False, show_leaf_counts=False, i=-1, iv=0.0, ivl=[], n=0, icoord_list=[], dcoord_list=[], lvs=None, mhr=False, current_color=[], color_list=[], currently_below_threshold=[], leaf_label_func=None, level=0, contraction_marks=None, link_color_func=None, above_threshold_color='b')"",)",scipy,1.1.0,scipy.cluster.hierarchy._dendrogram_calculate_info,cluster.hierarchy,_dendrogram_calculate_info,"Python Library Documentation: function _dendrogram_calculate_info in module scipy.cluster.hierarchy

_dendrogram_calculate_info(Z, p, truncate_mode, color_threshold=inf, get_leaves=True, orientation='top', labels=None, count_sort=False, distance_sort=False, show_leaf_counts=False, i=-1, iv=0.0, ivl=[], n=0, icoord_list=[], dcoord_list=[], lvs=None, mhr=False, current_color=[], color_list=[], currently_below_threshold=[], leaf_label_func=None, level=0, contraction_marks=None, link_color_func=None, above_threshold_color='b')
    Calculate the endpoints of the links as well as the labels for the
    the dendrogram rooted at the node with index i. iv is the independent
    variable value to plot the left-most leaf node below the root node i
    (if orientation='top', this would be the left-most x value where the
    plotting of this root node i and its descendents should begin).
    
    ivl is a list to store the labels of the leaf nodes. The leaf_label_func
    is called whenever ivl != None, labels == None, and
    leaf_label_func != None. When ivl != None and labels != None, the
    labels list is used only for labeling the leaf nodes. When
    ivl == None, no labels are generated for leaf nodes.
    
    When get_leaves==True, a list of leaves is built as they are visited
    in the dendrogram.
    
    Returns a tuple with l being the independent variable coordinate that
    corresponds to the midpoint of cluster to the left of cluster i if
    i is non-singleton, otherwise the independent coordinate of the leaf
    node if i is a leaf node.
    
    Returns
    -------
    A tuple (left, w, h, md), where:
    
      * left is the independent variable coordinate of the center of the
        the U of the subtree
    
      * w is the amount of space used for the subtree (in independent
        variable units)
    
      * h is the height of the subtree in dependent variable units
    
      * md is the ``max(Z[*,2]``) for all nodes ``*`` below and including
        the target node.
",function,"('Z', 'p', 'truncate_mode', 'color_threshold', 'get_leaves', 'orientation', 'labels', 'count_sort', 'distance_sort', 'show_leaf_counts', 'i', 'iv', 'ivl', 'n', 'icoord_list', 'dcoord_list', 'lvs', 'mhr', 'current_color', 'color_list', 'currently_below_threshold', 'leaf_label_func', 'level', 'contraction_marks', 'link_color_func', 'above_threshold_color')","(nan, nan, nan, inf, True, 'top', None, False, False, False, -1, 0.0, [], 0, [], [], None, False, [], [], [], None, 0, None, None, 'b')","(nan, nan, nan, 'float', 'bool', 'str', 'NoneType', 'bool', 'bool', 'bool', 'int', 'float', 'list', 'int', 'list', 'list', 'NoneType', 'bool', 'list', 'list', 'list', 'NoneType', 'int', 'NoneType', 'NoneType', 'str')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(Z, p, truncate_mode, color_threshold=inf, get_leaves=True, orientation='top', labels=None, count_sort=False, distance_sort=False, show_leaf_counts=False, i=-1, iv=0.0, ivl=[], n=0, icoord_list=[], dcoord_list=[], lvs=None, mhr=False, current_color=[], color_list=[], currently_below_threshold=[], leaf_label_func=None, level=0, contraction_marks=None, link_color_func=None, above_threshold_color='b')"",)"
scipy,1.1.0,scipy.cluster.hierarchy._get_tick_rotation,cluster.hierarchy,_get_tick_rotation,"Python Library Documentation: function _get_tick_rotation in module scipy.cluster.hierarchy

_get_tick_rotation(p)
",function,"('(p)',)",scipy,1.1.0,scipy.cluster.hierarchy._get_tick_rotation,cluster.hierarchy,_get_tick_rotation,"Python Library Documentation: function _get_tick_rotation in module scipy.cluster.hierarchy

_get_tick_rotation(p)
",function,"('p',)","(nan,)","(nan,)","('arg_info',)","('(p)',)"
scipy,1.1.0,scipy.cluster.hierarchy._get_tick_text_size,cluster.hierarchy,_get_tick_text_size,"Python Library Documentation: function _get_tick_text_size in module scipy.cluster.hierarchy

_get_tick_text_size(p)
",function,"('(p)',)",scipy,1.1.0,scipy.cluster.hierarchy._get_tick_text_size,cluster.hierarchy,_get_tick_text_size,"Python Library Documentation: function _get_tick_text_size in module scipy.cluster.hierarchy

_get_tick_text_size(p)
",function,"('p',)","(nan,)","(nan,)","('arg_info',)","('(p)',)"
scipy,1.1.0,scipy.cluster.hierarchy._order_cluster_tree,cluster.hierarchy,_order_cluster_tree,"Python Library Documentation: function _order_cluster_tree in module scipy.cluster.hierarchy

_order_cluster_tree(Z)
    Return clustering nodes in bottom-up order by distance.
    
    Parameters
    ----------
    Z : scipy.cluster.linkage array
        The linkage matrix.
    
    Returns
    -------
    nodes : list
        A list of ClusterNode objects.
",function,"('(Z)',)",scipy,1.1.0,scipy.cluster.hierarchy._order_cluster_tree,cluster.hierarchy,_order_cluster_tree,"Python Library Documentation: function _order_cluster_tree in module scipy.cluster.hierarchy

_order_cluster_tree(Z)
    Return clustering nodes in bottom-up order by distance.
    
    Parameters
    ----------
    Z : scipy.cluster.linkage array
        The linkage matrix.
    
    Returns
    -------
    nodes : list
        A list of ClusterNode objects.
",function,"('Z',)","(nan,)","(nan,)","('arg_info',)","('(Z)',)"
scipy,1.1.0,scipy.cluster.hierarchy._plot_dendrogram,cluster.hierarchy,_plot_dendrogram,"Python Library Documentation: function _plot_dendrogram in module scipy.cluster.hierarchy

_plot_dendrogram(icoords, dcoords, ivl, p, n, mh, orientation, no_labels, color_list, leaf_font_size=None, leaf_rotation=None, contraction_marks=None, ax=None, above_threshold_color='b')
",function,"(""(icoords, dcoords, ivl, p, n, mh, orientation, no_labels, color_list, leaf_font_size=None, leaf_rotation=None, contraction_marks=None, ax=None, above_threshold_color='b')"",)",scipy,1.1.0,scipy.cluster.hierarchy._plot_dendrogram,cluster.hierarchy,_plot_dendrogram,"Python Library Documentation: function _plot_dendrogram in module scipy.cluster.hierarchy

_plot_dendrogram(icoords, dcoords, ivl, p, n, mh, orientation, no_labels, color_list, leaf_font_size=None, leaf_rotation=None, contraction_marks=None, ax=None, above_threshold_color='b')
",function,"('icoords', 'dcoords', 'ivl', 'p', 'n', 'mh', 'orientation', 'no_labels', 'color_list', 'leaf_font_size', 'leaf_rotation', 'contraction_marks', 'ax', 'above_threshold_color')","(nan, nan, nan, nan, nan, nan, nan, nan, nan, None, None, None, None, 'b')","(nan, nan, nan, nan, nan, nan, nan, nan, nan, 'NoneType', 'NoneType', 'NoneType', 'NoneType', 'str')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(icoords, dcoords, ivl, p, n, mh, orientation, no_labels, color_list, leaf_font_size=None, leaf_rotation=None, contraction_marks=None, ax=None, above_threshold_color='b')"",)"
scipy,1.1.0,scipy.cluster.hierarchy._randdm,cluster.hierarchy,_randdm,"Python Library Documentation: function _randdm in module scipy.cluster.hierarchy

_randdm(pnts)
    Generate a random distance matrix stored in condensed form.
    
    Parameters
    ----------
    pnts : int
        The number of points in the distance matrix. Has to be at least 2.
    
    Returns
    -------
    D : ndarray
        A ``pnts * (pnts - 1) / 2`` sized vector is returned.
",function,"('(pnts)',)",scipy,1.1.0,scipy.cluster.hierarchy._randdm,cluster.hierarchy,_randdm,"Python Library Documentation: function _randdm in module scipy.cluster.hierarchy

_randdm(pnts)
    Generate a random distance matrix stored in condensed form.
    
    Parameters
    ----------
    pnts : int
        The number of points in the distance matrix. Has to be at least 2.
    
    Returns
    -------
    D : ndarray
        A ``pnts * (pnts - 1) / 2`` sized vector is returned.
",function,"('pnts',)","(nan,)","(nan,)","('arg_info',)","('(pnts)',)"
scipy,1.1.0,scipy.cluster.hierarchy._remove_dups,cluster.hierarchy,_remove_dups,"Python Library Documentation: function _remove_dups in module scipy.cluster.hierarchy

_remove_dups(L)
    Remove duplicates AND preserve the original order of the elements.
    
    The set class is not guaranteed to do this.
",function,"('(L)',)",scipy,1.1.0,scipy.cluster.hierarchy._remove_dups,cluster.hierarchy,_remove_dups,"Python Library Documentation: function _remove_dups in module scipy.cluster.hierarchy

_remove_dups(L)
    Remove duplicates AND preserve the original order of the elements.
    
    The set class is not guaranteed to do this.
",function,"('L',)","(nan,)","(nan,)","('arg_info',)","('(L)',)"
scipy,1.1.0,scipy.cluster.hierarchy._warning,cluster.hierarchy,_warning,"Python Library Documentation: function _warning in module scipy.cluster.hierarchy

_warning(s)
",function,"('(s)',)",scipy,1.1.0,scipy.cluster.hierarchy._warning,cluster.hierarchy,_warning,"Python Library Documentation: function _warning in module scipy.cluster.hierarchy

_warning(s)
",function,"('s',)","(nan,)","(nan,)","('arg_info',)","('(s)',)"
scipy,1.1.0,scipy.cluster.hierarchy.average,cluster.hierarchy,average,"Python Library Documentation: function average in module scipy.cluster.hierarchy

average(y)
    Perform average/UPGMA linkage on a condensed distance matrix.
    
    Parameters
    ----------
    y : ndarray
        The upper triangular of the distance matrix. The result of
        ``pdist`` is returned in this form.
    
    Returns
    -------
    Z : ndarray
        A linkage matrix containing the hierarchical clustering. See
        `linkage` for more information on its structure.
    
    See Also
    --------
    linkage: for advanced creation of hierarchical clusterings.
    scipy.spatial.distance.pdist : pairwise distance metrics
",function,"('(y)',)",scipy,1.1.0,scipy.cluster.hierarchy.average,cluster.hierarchy,average,"Python Library Documentation: function average in module scipy.cluster.hierarchy

average(y)
    Perform average/UPGMA linkage on a condensed distance matrix.
    
    Parameters
    ----------
    y : ndarray
        The upper triangular of the distance matrix. The result of
        ``pdist`` is returned in this form.
    
    Returns
    -------
    Z : ndarray
        A linkage matrix containing the hierarchical clustering. See
        `linkage` for more information on its structure.
    
    See Also
    --------
    linkage: for advanced creation of hierarchical clusterings.
    scipy.spatial.distance.pdist : pairwise distance metrics
",function,"('y',)","(nan,)","(nan,)","('arg_info',)","('(y)',)"
scipy,1.1.0,scipy.cluster.hierarchy.centroid,cluster.hierarchy,centroid,"Python Library Documentation: function centroid in module scipy.cluster.hierarchy

centroid(y)
    Perform centroid/UPGMC linkage.
    
    See `linkage` for more information on the input matrix,
    return structure, and algorithm.
    
    The following are common calling conventions:
    
    1. ``Z = centroid(y)``
    
       Performs centroid/UPGMC linkage on the condensed distance
       matrix ``y``.
    
    2. ``Z = centroid(X)``
    
       Performs centroid/UPGMC linkage on the observation matrix ``X``
       using Euclidean distance as the distance metric.
    
    Parameters
    ----------
    y : ndarray
        A condensed distance matrix. A condensed
        distance matrix is a flat array containing the upper
        triangular of the distance matrix. This is the form that
        ``pdist`` returns. Alternatively, a collection of
        m observation vectors in n dimensions may be passed as
        a m by n array.
    
    Returns
    -------
    Z : ndarray
        A linkage matrix containing the hierarchical clustering. See
        the `linkage` function documentation for more information
        on its structure.
    
    See Also
    --------
    linkage: for advanced creation of hierarchical clusterings.
",function,"('(y)',)",scipy,1.1.0,scipy.cluster.hierarchy.centroid,cluster.hierarchy,centroid,"Python Library Documentation: function centroid in module scipy.cluster.hierarchy

centroid(y)
    Perform centroid/UPGMC linkage.
    
    See `linkage` for more information on the input matrix,
    return structure, and algorithm.
    
    The following are common calling conventions:
    
    1. ``Z = centroid(y)``
    
       Performs centroid/UPGMC linkage on the condensed distance
       matrix ``y``.
    
    2. ``Z = centroid(X)``
    
       Performs centroid/UPGMC linkage on the observation matrix ``X``
       using Euclidean distance as the distance metric.
    
    Parameters
    ----------
    y : ndarray
        A condensed distance matrix. A condensed
        distance matrix is a flat array containing the upper
        triangular of the distance matrix. This is the form that
        ``pdist`` returns. Alternatively, a collection of
        m observation vectors in n dimensions may be passed as
        a m by n array.
    
    Returns
    -------
    Z : ndarray
        A linkage matrix containing the hierarchical clustering. See
        the `linkage` function documentation for more information
        on its structure.
    
    See Also
    --------
    linkage: for advanced creation of hierarchical clusterings.
",function,"('y',)","(nan,)","(nan,)","('arg_info',)","('(y)',)"
scipy,1.1.0,scipy.cluster.hierarchy.complete,cluster.hierarchy,complete,"Python Library Documentation: function complete in module scipy.cluster.hierarchy

complete(y)
    Perform complete/max/farthest point linkage on a condensed distance matrix.
    
    Parameters
    ----------
    y : ndarray
        The upper triangular of the distance matrix. The result of
        ``pdist`` is returned in this form.
    
    Returns
    -------
    Z : ndarray
        A linkage matrix containing the hierarchical clustering. See
        the `linkage` function documentation for more information
        on its structure.
    
    See Also
    --------
    linkage: for advanced creation of hierarchical clusterings.
    scipy.spatial.distance.pdist : pairwise distance metrics
",function,"('(y)',)",scipy,1.1.0,scipy.cluster.hierarchy.complete,cluster.hierarchy,complete,"Python Library Documentation: function complete in module scipy.cluster.hierarchy

complete(y)
    Perform complete/max/farthest point linkage on a condensed distance matrix.
    
    Parameters
    ----------
    y : ndarray
        The upper triangular of the distance matrix. The result of
        ``pdist`` is returned in this form.
    
    Returns
    -------
    Z : ndarray
        A linkage matrix containing the hierarchical clustering. See
        the `linkage` function documentation for more information
        on its structure.
    
    See Also
    --------
    linkage: for advanced creation of hierarchical clusterings.
    scipy.spatial.distance.pdist : pairwise distance metrics
",function,"('y',)","(nan,)","(nan,)","('arg_info',)","('(y)',)"
scipy,1.1.0,scipy.cluster.hierarchy.cophenet,cluster.hierarchy,cophenet,"Python Library Documentation: function cophenet in module scipy.cluster.hierarchy

cophenet(Z, Y=None)
    Calculate the cophenetic distances between each observation in
    the hierarchical clustering defined by the linkage ``Z``.
    
    Suppose ``p`` and ``q`` are original observations in
    disjoint clusters ``s`` and ``t``, respectively and
    ``s`` and ``t`` are joined by a direct parent cluster
    ``u``. The cophenetic distance between observations
    ``i`` and ``j`` is simply the distance between
    clusters ``s`` and ``t``.
    
    Parameters
    ----------
    Z : ndarray
        The hierarchical clustering encoded as an array
        (see `linkage` function).
    Y : ndarray (optional)
        Calculates the cophenetic correlation coefficient ``c`` of a
        hierarchical clustering defined by the linkage matrix `Z`
        of a set of :math:`n` observations in :math:`m`
        dimensions. `Y` is the condensed distance matrix from which
        `Z` was generated.
    
    Returns
    -------
    c : ndarray
        The cophentic correlation distance (if ``Y`` is passed).
    d : ndarray
        The cophenetic distance matrix in condensed form. The
        :math:`ij` th entry is the cophenetic distance between
        original observations :math:`i` and :math:`j`.
",function,"('(Z, Y=None)',)",scipy,1.1.0,scipy.cluster.hierarchy.cophenet,cluster.hierarchy,cophenet,"Python Library Documentation: function cophenet in module scipy.cluster.hierarchy

cophenet(Z, Y=None)
    Calculate the cophenetic distances between each observation in
    the hierarchical clustering defined by the linkage ``Z``.
    
    Suppose ``p`` and ``q`` are original observations in
    disjoint clusters ``s`` and ``t``, respectively and
    ``s`` and ``t`` are joined by a direct parent cluster
    ``u``. The cophenetic distance between observations
    ``i`` and ``j`` is simply the distance between
    clusters ``s`` and ``t``.
    
    Parameters
    ----------
    Z : ndarray
        The hierarchical clustering encoded as an array
        (see `linkage` function).
    Y : ndarray (optional)
        Calculates the cophenetic correlation coefficient ``c`` of a
        hierarchical clustering defined by the linkage matrix `Z`
        of a set of :math:`n` observations in :math:`m`
        dimensions. `Y` is the condensed distance matrix from which
        `Z` was generated.
    
    Returns
    -------
    c : ndarray
        The cophentic correlation distance (if ``Y`` is passed).
    d : ndarray
        The cophenetic distance matrix in condensed form. The
        :math:`ij` th entry is the cophenetic distance between
        original observations :math:`i` and :math:`j`.
",function,"('Z', 'Y')","(nan, None)","(nan, 'NoneType')","('arg_info', 'arg_info')","('(Z, Y=None)',)"
scipy,1.1.0,scipy.cluster.hierarchy.correspond,cluster.hierarchy,correspond,"Python Library Documentation: function correspond in module scipy.cluster.hierarchy

correspond(Z, Y)
    Check for correspondence between linkage and condensed distance matrices.
    
    They must have the same number of original observations for
    the check to succeed.
    
    This function is useful as a sanity check in algorithms that make
    extensive use of linkage and distance matrices that must
    correspond to the same set of original observations.
    
    Parameters
    ----------
    Z : array_like
        The linkage matrix to check for correspondence.
    Y : array_like
        The condensed distance matrix to check for correspondence.
    
    Returns
    -------
    b : bool
        A boolean indicating whether the linkage matrix and distance
        matrix could possibly correspond to one another.
",function,"('(Z, Y)',)",scipy,1.1.0,scipy.cluster.hierarchy.correspond,cluster.hierarchy,correspond,"Python Library Documentation: function correspond in module scipy.cluster.hierarchy

correspond(Z, Y)
    Check for correspondence between linkage and condensed distance matrices.
    
    They must have the same number of original observations for
    the check to succeed.
    
    This function is useful as a sanity check in algorithms that make
    extensive use of linkage and distance matrices that must
    correspond to the same set of original observations.
    
    Parameters
    ----------
    Z : array_like
        The linkage matrix to check for correspondence.
    Y : array_like
        The condensed distance matrix to check for correspondence.
    
    Returns
    -------
    b : bool
        A boolean indicating whether the linkage matrix and distance
        matrix could possibly correspond to one another.
",function,"('Z', 'Y')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(Z, Y)',)"
scipy,1.1.0,scipy.cluster.hierarchy.cut_tree,cluster.hierarchy,cut_tree,"Python Library Documentation: function cut_tree in module scipy.cluster.hierarchy

cut_tree(Z, n_clusters=None, height=None)
    Given a linkage matrix Z, return the cut tree.
    
    Parameters
    ----------
    Z : scipy.cluster.linkage array
        The linkage matrix.
    n_clusters : array_like, optional
        Number of clusters in the tree at the cut point.
    height : array_like, optional
        The height at which to cut the tree.  Only possible for ultrametric
        trees.
    
    Returns
    -------
    cutree : array
        An array indicating group membership at each agglomeration step.  I.e.,
        for a full cut tree, in the first column each data point is in its own
        cluster.  At the next step, two nodes are merged.  Finally all
        singleton and non-singleton clusters are in one group.  If `n_clusters`
        or `height` is given, the columns correspond to the columns of
        `n_clusters` or `height`.
    
    Examples
    --------
    >>> from scipy import cluster
    >>> np.random.seed(23)
    >>> X = np.random.randn(50, 4)
    >>> Z = cluster.hierarchy.ward(X)
    >>> cutree = cluster.hierarchy.cut_tree(Z, n_clusters=[5, 10])
    >>> cutree[:10]
    array([[0, 0],
           [1, 1],
           [2, 2],
           [3, 3],
           [3, 4],
           [2, 2],
           [0, 0],
           [1, 5],
           [3, 6],
           [4, 7]])
",function,"('(Z, n_clusters=None, height=None)',)",scipy,1.1.0,scipy.cluster.hierarchy.cut_tree,cluster.hierarchy,cut_tree,"Python Library Documentation: function cut_tree in module scipy.cluster.hierarchy

cut_tree(Z, n_clusters=None, height=None)
    Given a linkage matrix Z, return the cut tree.
    
    Parameters
    ----------
    Z : scipy.cluster.linkage array
        The linkage matrix.
    n_clusters : array_like, optional
        Number of clusters in the tree at the cut point.
    height : array_like, optional
        The height at which to cut the tree.  Only possible for ultrametric
        trees.
    
    Returns
    -------
    cutree : array
        An array indicating group membership at each agglomeration step.  I.e.,
        for a full cut tree, in the first column each data point is in its own
        cluster.  At the next step, two nodes are merged.  Finally all
        singleton and non-singleton clusters are in one group.  If `n_clusters`
        or `height` is given, the columns correspond to the columns of
        `n_clusters` or `height`.
    
    Examples
    --------
    >>> from scipy import cluster
    >>> np.random.seed(23)
    >>> X = np.random.randn(50, 4)
    >>> Z = cluster.hierarchy.ward(X)
    >>> cutree = cluster.hierarchy.cut_tree(Z, n_clusters=[5, 10])
    >>> cutree[:10]
    array([[0, 0],
           [1, 1],
           [2, 2],
           [3, 3],
           [3, 4],
           [2, 2],
           [0, 0],
           [1, 5],
           [3, 6],
           [4, 7]])
",function,"('Z', 'n_clusters', 'height')","(nan, None, None)","(nan, 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(Z, n_clusters=None, height=None)',)"
scipy,1.1.0,scipy.cluster.hierarchy.dendrogram,cluster.hierarchy,dendrogram,"Python Library Documentation: function dendrogram in module scipy.cluster.hierarchy

dendrogram(Z, p=30, truncate_mode=None, color_threshold=None, get_leaves=True, orientation='top', labels=None, count_sort=False, distance_sort=False, show_leaf_counts=True, no_plot=False, no_labels=False, leaf_font_size=None, leaf_rotation=None, leaf_label_func=None, show_contracted=False, link_color_func=None, ax=None, above_threshold_color='b')
    Plot the hierarchical clustering as a dendrogram.
    
    The dendrogram illustrates how each cluster is
    composed by drawing a U-shaped link between a non-singleton
    cluster and its children.  The top of the U-link indicates a
    cluster merge.  The two legs of the U-link indicate which clusters
    were merged.  The length of the two legs of the U-link represents
    the distance between the child clusters.  It is also the
    cophenetic distance between original observations in the two
    children clusters.
    
    Parameters
    ----------
    Z : ndarray
        The linkage matrix encoding the hierarchical clustering to
        render as a dendrogram. See the ``linkage`` function for more
        information on the format of ``Z``.
    p : int, optional
        The ``p`` parameter for ``truncate_mode``.
    truncate_mode : str, optional
        The dendrogram can be hard to read when the original
        observation matrix from which the linkage is derived is
        large. Truncation is used to condense the dendrogram. There
        are several modes:
    
        ``None``
          No truncation is performed (default).
          Note: ``'none'`` is an alias for ``None`` that's kept for
          backward compatibility.
    
        ``'lastp'``
          The last ``p`` non-singleton clusters formed in the linkage are the
          only non-leaf nodes in the linkage; they correspond to rows
          ``Z[n-p-2:end]`` in ``Z``. All other non-singleton clusters are
          contracted into leaf nodes.
    
        ``'level'``
          No more than ``p`` levels of the dendrogram tree are displayed.
          A ""level"" includes all nodes with ``p`` merges from the last merge.
    
          Note: ``'mtica'`` is an alias for ``'level'`` that's kept for
          backward compatibility.
    
    color_threshold : double, optional
        For brevity, let :math:`t` be the ``color_threshold``.
        Colors all the descendent links below a cluster node
        :math:`k` the same color if :math:`k` is the first node below
        the cut threshold :math:`t`. All links connecting nodes with
        distances greater than or equal to the threshold are colored
        blue. If :math:`t` is less than or equal to zero, all nodes
        are colored blue. If ``color_threshold`` is None or
        'default', corresponding with MATLAB(TM) behavior, the
        threshold is set to ``0.7*max(Z[:,2])``.
    get_leaves : bool, optional
        Includes a list ``R['leaves']=H`` in the result
        dictionary. For each :math:`i`, ``H[i] == j``, cluster node
        ``j`` appears in position ``i`` in the left-to-right traversal
        of the leaves, where :math:`j < 2n-1` and :math:`i < n`.
    orientation : str, optional
        The direction to plot the dendrogram, which can be any
        of the following strings:
    
        ``'top'``
          Plots the root at the top, and plot descendent links going downwards.
          (default).
    
        ``'bottom'``
          Plots the root at the bottom, and plot descendent links going
          upwards.
    
        ``'left'``
          Plots the root at the left, and plot descendent links going right.
    
        ``'right'``
          Plots the root at the right, and plot descendent links going left.
    
    labels : ndarray, optional
        By default ``labels`` is None so the index of the original observation
        is used to label the leaf nodes.  Otherwise, this is an :math:`n`
        -sized list (or tuple). The ``labels[i]`` value is the text to put
        under the :math:`i` th leaf node only if it corresponds to an original
        observation and not a non-singleton cluster.
    count_sort : str or bool, optional
        For each node n, the order (visually, from left-to-right) n's
        two descendent links are plotted is determined by this
        parameter, which can be any of the following values:
    
        ``False``
          Nothing is done.
    
        ``'ascending'`` or ``True``
          The child with the minimum number of original objects in its cluster
          is plotted first.
    
        ``'descendent'``
          The child with the maximum number of original objects in its cluster
          is plotted first.
    
        Note ``distance_sort`` and ``count_sort`` cannot both be True.
    distance_sort : str or bool, optional
        For each node n, the order (visually, from left-to-right) n's
        two descendent links are plotted is determined by this
        parameter, which can be any of the following values:
    
        ``False``
          Nothing is done.
    
        ``'ascending'`` or ``True``
          The child with the minimum distance between its direct descendents is
          plotted first.
    
        ``'descending'``
          The child with the maximum distance between its direct descendents is
          plotted first.
    
        Note ``distance_sort`` and ``count_sort`` cannot both be True.
    show_leaf_counts : bool, optional
         When True, leaf nodes representing :math:`k>1` original
         observation are labeled with the number of observations they
         contain in parentheses.
    no_plot : bool, optional
        When True, the final rendering is not performed. This is
        useful if only the data structures computed for the rendering
        are needed or if matplotlib is not available.
    no_labels : bool, optional
        When True, no labels appear next to the leaf nodes in the
        rendering of the dendrogram.
    leaf_rotation : double, optional
        Specifies the angle (in degrees) to rotate the leaf
        labels. When unspecified, the rotation is based on the number of
        nodes in the dendrogram (default is 0).
    leaf_font_size : int, optional
        Specifies the font size (in points) of the leaf labels. When
        unspecified, the size based on the number of nodes in the
        dendrogram.
    leaf_label_func : lambda or function, optional
        When leaf_label_func is a callable function, for each
        leaf with cluster index :math:`k < 2n-1`. The function
        is expected to return a string with the label for the
        leaf.
    
        Indices :math:`k < n` correspond to original observations
        while indices :math:`k \geq n` correspond to non-singleton
        clusters.
    
        For example, to label singletons with their node id and
        non-singletons with their id, count, and inconsistency
        coefficient, simply do::
    
            # First define the leaf label function.
            def llf(id):
                if id < n:
                    return str(id)
                else:
                    return '[%d %d %1.2f]' % (id, count, R[n-id,3])
            # The text for the leaf nodes is going to be big so force
            # a rotation of 90 degrees.
            dendrogram(Z, leaf_label_func=llf, leaf_rotation=90)
    
    show_contracted : bool, optional
        When True the heights of non-singleton nodes contracted
        into a leaf node are plotted as crosses along the link
        connecting that leaf node.  This really is only useful when
        truncation is used (see ``truncate_mode`` parameter).
    link_color_func : callable, optional
        If given, `link_color_function` is called with each non-singleton id
        corresponding to each U-shaped link it will paint. The function is
        expected to return the color to paint the link, encoded as a matplotlib
        color string code. For example::
    
            dendrogram(Z, link_color_func=lambda k: colors[k])
    
        colors the direct links below each untruncated non-singleton node
        ``k`` using ``colors[k]``.
    ax : matplotlib Axes instance, optional
        If None and `no_plot` is not True, the dendrogram will be plotted
        on the current axes.  Otherwise if `no_plot` is not True the
        dendrogram will be plotted on the given ``Axes`` instance. This can be
        useful if the dendrogram is part of a more complex figure.
    above_threshold_color : str, optional
        This matplotlib color string sets the color of the links above the
        color_threshold. The default is 'b'.
    
    Returns
    -------
    R : dict
        A dictionary of data structures computed to render the
        dendrogram. Its has the following keys:
    
        ``'color_list'``
          A list of color names. The k'th element represents the color of the
          k'th link.
    
        ``'icoord'`` and ``'dcoord'``
          Each of them is a list of lists. Let ``icoord = [I1, I2, ..., Ip]``
          where ``Ik = [xk1, xk2, xk3, xk4]`` and ``dcoord = [D1, D2, ..., Dp]``
          where ``Dk = [yk1, yk2, yk3, yk4]``, then the k'th link painted is
          ``(xk1, yk1)`` - ``(xk2, yk2)`` - ``(xk3, yk3)`` - ``(xk4, yk4)``.
    
        ``'ivl'``
          A list of labels corresponding to the leaf nodes.
    
        ``'leaves'``
          For each i, ``H[i] == j``, cluster node ``j`` appears in position
          ``i`` in the left-to-right traversal of the leaves, where
          :math:`j < 2n-1` and :math:`i < n`. If ``j`` is less than ``n``, the
          ``i``-th leaf node corresponds to an original observation.
          Otherwise, it corresponds to a non-singleton cluster.
    
    See Also
    --------
    linkage, set_link_color_palette
    
    Notes
    -----
    It is expected that the distances in ``Z[:,2]`` be monotonic, otherwise
    crossings appear in the dendrogram.
    
    Examples
    --------
    >>> from scipy.cluster import hierarchy
    >>> import matplotlib.pyplot as plt
    
    A very basic example:
    
    >>> ytdist = np.array([662., 877., 255., 412., 996., 295., 468., 268.,
    ...                    400., 754., 564., 138., 219., 869., 669.])
    >>> Z = hierarchy.linkage(ytdist, 'single')
    >>> plt.figure()
    >>> dn = hierarchy.dendrogram(Z)
    
    Now plot in given axes, improve the color scheme and use both vertical and
    horizontal orientations:
    
    >>> hierarchy.set_link_color_palette(['m', 'c', 'y', 'k'])
    >>> fig, axes = plt.subplots(1, 2, figsize=(8, 3))
    >>> dn1 = hierarchy.dendrogram(Z, ax=axes[0], above_threshold_color='y',
    ...                            orientation='top')
    >>> dn2 = hierarchy.dendrogram(Z, ax=axes[1],
    ...                            above_threshold_color='#bcbddc',
    ...                            orientation='right')
    >>> hierarchy.set_link_color_palette(None)  # reset to default after use
    >>> plt.show()
",function,"(""(Z, p=30, truncate_mode=None, color_threshold=None, get_leaves=True, orientation='top', labels=None, count_sort=False, distance_sort=False, show_leaf_counts=True, no_plot=False, no_labels=False, leaf_font_size=None, leaf_rotation=None, leaf_label_func=None, show_contracted=False, link_color_func=None, ax=None, above_threshold_color='b')"",)",scipy,1.1.0,scipy.cluster.hierarchy.dendrogram,cluster.hierarchy,dendrogram,"Python Library Documentation: function dendrogram in module scipy.cluster.hierarchy

dendrogram(Z, p=30, truncate_mode=None, color_threshold=None, get_leaves=True, orientation='top', labels=None, count_sort=False, distance_sort=False, show_leaf_counts=True, no_plot=False, no_labels=False, leaf_font_size=None, leaf_rotation=None, leaf_label_func=None, show_contracted=False, link_color_func=None, ax=None, above_threshold_color='b')
    Plot the hierarchical clustering as a dendrogram.
    
    The dendrogram illustrates how each cluster is
    composed by drawing a U-shaped link between a non-singleton
    cluster and its children.  The top of the U-link indicates a
    cluster merge.  The two legs of the U-link indicate which clusters
    were merged.  The length of the two legs of the U-link represents
    the distance between the child clusters.  It is also the
    cophenetic distance between original observations in the two
    children clusters.
    
    Parameters
    ----------
    Z : ndarray
        The linkage matrix encoding the hierarchical clustering to
        render as a dendrogram. See the ``linkage`` function for more
        information on the format of ``Z``.
    p : int, optional
        The ``p`` parameter for ``truncate_mode``.
    truncate_mode : str, optional
        The dendrogram can be hard to read when the original
        observation matrix from which the linkage is derived is
        large. Truncation is used to condense the dendrogram. There
        are several modes:
    
        ``None``
          No truncation is performed (default).
          Note: ``'none'`` is an alias for ``None`` that's kept for
          backward compatibility.
    
        ``'lastp'``
          The last ``p`` non-singleton clusters formed in the linkage are the
          only non-leaf nodes in the linkage; they correspond to rows
          ``Z[n-p-2:end]`` in ``Z``. All other non-singleton clusters are
          contracted into leaf nodes.
    
        ``'level'``
          No more than ``p`` levels of the dendrogram tree are displayed.
          A ""level"" includes all nodes with ``p`` merges from the last merge.
    
          Note: ``'mtica'`` is an alias for ``'level'`` that's kept for
          backward compatibility.
    
    color_threshold : double, optional
        For brevity, let :math:`t` be the ``color_threshold``.
        Colors all the descendent links below a cluster node
        :math:`k` the same color if :math:`k` is the first node below
        the cut threshold :math:`t`. All links connecting nodes with
        distances greater than or equal to the threshold are colored
        blue. If :math:`t` is less than or equal to zero, all nodes
        are colored blue. If ``color_threshold`` is None or
        'default', corresponding with MATLAB(TM) behavior, the
        threshold is set to ``0.7*max(Z[:,2])``.
    get_leaves : bool, optional
        Includes a list ``R['leaves']=H`` in the result
        dictionary. For each :math:`i`, ``H[i] == j``, cluster node
        ``j`` appears in position ``i`` in the left-to-right traversal
        of the leaves, where :math:`j < 2n-1` and :math:`i < n`.
    orientation : str, optional
        The direction to plot the dendrogram, which can be any
        of the following strings:
    
        ``'top'``
          Plots the root at the top, and plot descendent links going downwards.
          (default).
    
        ``'bottom'``
          Plots the root at the bottom, and plot descendent links going
          upwards.
    
        ``'left'``
          Plots the root at the left, and plot descendent links going right.
    
        ``'right'``
          Plots the root at the right, and plot descendent links going left.
    
    labels : ndarray, optional
        By default ``labels`` is None so the index of the original observation
        is used to label the leaf nodes.  Otherwise, this is an :math:`n`
        -sized list (or tuple). The ``labels[i]`` value is the text to put
        under the :math:`i` th leaf node only if it corresponds to an original
        observation and not a non-singleton cluster.
    count_sort : str or bool, optional
        For each node n, the order (visually, from left-to-right) n's
        two descendent links are plotted is determined by this
        parameter, which can be any of the following values:
    
        ``False``
          Nothing is done.
    
        ``'ascending'`` or ``True``
          The child with the minimum number of original objects in its cluster
          is plotted first.
    
        ``'descendent'``
          The child with the maximum number of original objects in its cluster
          is plotted first.
    
        Note ``distance_sort`` and ``count_sort`` cannot both be True.
    distance_sort : str or bool, optional
        For each node n, the order (visually, from left-to-right) n's
        two descendent links are plotted is determined by this
        parameter, which can be any of the following values:
    
        ``False``
          Nothing is done.
    
        ``'ascending'`` or ``True``
          The child with the minimum distance between its direct descendents is
          plotted first.
    
        ``'descending'``
          The child with the maximum distance between its direct descendents is
          plotted first.
    
        Note ``distance_sort`` and ``count_sort`` cannot both be True.
    show_leaf_counts : bool, optional
         When True, leaf nodes representing :math:`k>1` original
         observation are labeled with the number of observations they
         contain in parentheses.
    no_plot : bool, optional
        When True, the final rendering is not performed. This is
        useful if only the data structures computed for the rendering
        are needed or if matplotlib is not available.
    no_labels : bool, optional
        When True, no labels appear next to the leaf nodes in the
        rendering of the dendrogram.
    leaf_rotation : double, optional
        Specifies the angle (in degrees) to rotate the leaf
        labels. When unspecified, the rotation is based on the number of
        nodes in the dendrogram (default is 0).
    leaf_font_size : int, optional
        Specifies the font size (in points) of the leaf labels. When
        unspecified, the size based on the number of nodes in the
        dendrogram.
    leaf_label_func : lambda or function, optional
        When leaf_label_func is a callable function, for each
        leaf with cluster index :math:`k < 2n-1`. The function
        is expected to return a string with the label for the
        leaf.
    
        Indices :math:`k < n` correspond to original observations
        while indices :math:`k \geq n` correspond to non-singleton
        clusters.
    
        For example, to label singletons with their node id and
        non-singletons with their id, count, and inconsistency
        coefficient, simply do::
    
            # First define the leaf label function.
            def llf(id):
                if id < n:
                    return str(id)
                else:
                    return '[%d %d %1.2f]' % (id, count, R[n-id,3])
            # The text for the leaf nodes is going to be big so force
            # a rotation of 90 degrees.
            dendrogram(Z, leaf_label_func=llf, leaf_rotation=90)
    
    show_contracted : bool, optional
        When True the heights of non-singleton nodes contracted
        into a leaf node are plotted as crosses along the link
        connecting that leaf node.  This really is only useful when
        truncation is used (see ``truncate_mode`` parameter).
    link_color_func : callable, optional
        If given, `link_color_function` is called with each non-singleton id
        corresponding to each U-shaped link it will paint. The function is
        expected to return the color to paint the link, encoded as a matplotlib
        color string code. For example::
    
            dendrogram(Z, link_color_func=lambda k: colors[k])
    
        colors the direct links below each untruncated non-singleton node
        ``k`` using ``colors[k]``.
    ax : matplotlib Axes instance, optional
        If None and `no_plot` is not True, the dendrogram will be plotted
        on the current axes.  Otherwise if `no_plot` is not True the
        dendrogram will be plotted on the given ``Axes`` instance. This can be
        useful if the dendrogram is part of a more complex figure.
    above_threshold_color : str, optional
        This matplotlib color string sets the color of the links above the
        color_threshold. The default is 'b'.
    
    Returns
    -------
    R : dict
        A dictionary of data structures computed to render the
        dendrogram. Its has the following keys:
    
        ``'color_list'``
          A list of color names. The k'th element represents the color of the
          k'th link.
    
        ``'icoord'`` and ``'dcoord'``
          Each of them is a list of lists. Let ``icoord = [I1, I2, ..., Ip]``
          where ``Ik = [xk1, xk2, xk3, xk4]`` and ``dcoord = [D1, D2, ..., Dp]``
          where ``Dk = [yk1, yk2, yk3, yk4]``, then the k'th link painted is
          ``(xk1, yk1)`` - ``(xk2, yk2)`` - ``(xk3, yk3)`` - ``(xk4, yk4)``.
    
        ``'ivl'``
          A list of labels corresponding to the leaf nodes.
    
        ``'leaves'``
          For each i, ``H[i] == j``, cluster node ``j`` appears in position
          ``i`` in the left-to-right traversal of the leaves, where
          :math:`j < 2n-1` and :math:`i < n`. If ``j`` is less than ``n``, the
          ``i``-th leaf node corresponds to an original observation.
          Otherwise, it corresponds to a non-singleton cluster.
    
    See Also
    --------
    linkage, set_link_color_palette
    
    Notes
    -----
    It is expected that the distances in ``Z[:,2]`` be monotonic, otherwise
    crossings appear in the dendrogram.
    
    Examples
    --------
    >>> from scipy.cluster import hierarchy
    >>> import matplotlib.pyplot as plt
    
    A very basic example:
    
    >>> ytdist = np.array([662., 877., 255., 412., 996., 295., 468., 268.,
    ...                    400., 754., 564., 138., 219., 869., 669.])
    >>> Z = hierarchy.linkage(ytdist, 'single')
    >>> plt.figure()
    >>> dn = hierarchy.dendrogram(Z)
    
    Now plot in given axes, improve the color scheme and use both vertical and
    horizontal orientations:
    
    >>> hierarchy.set_link_color_palette(['m', 'c', 'y', 'k'])
    >>> fig, axes = plt.subplots(1, 2, figsize=(8, 3))
    >>> dn1 = hierarchy.dendrogram(Z, ax=axes[0], above_threshold_color='y',
    ...                            orientation='top')
    >>> dn2 = hierarchy.dendrogram(Z, ax=axes[1],
    ...                            above_threshold_color='#bcbddc',
    ...                            orientation='right')
    >>> hierarchy.set_link_color_palette(None)  # reset to default after use
    >>> plt.show()
",function,"('Z', 'p', 'truncate_mode', 'color_threshold', 'get_leaves', 'orientation', 'labels', 'count_sort', 'distance_sort', 'show_leaf_counts', 'no_plot', 'no_labels', 'leaf_font_size', 'leaf_rotation', 'leaf_label_func', 'show_contracted', 'link_color_func', 'ax', 'above_threshold_color')","(nan, 30, None, None, True, 'top', None, False, False, True, False, False, None, None, None, False, None, None, 'b')","(nan, 'int', 'NoneType', 'NoneType', 'bool', 'str', 'NoneType', 'bool', 'bool', 'bool', 'bool', 'bool', 'NoneType', 'NoneType', 'NoneType', 'bool', 'NoneType', 'NoneType', 'str')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(Z, p=30, truncate_mode=None, color_threshold=None, get_leaves=True, orientation='top', labels=None, count_sort=False, distance_sort=False, show_leaf_counts=True, no_plot=False, no_labels=False, leaf_font_size=None, leaf_rotation=None, leaf_label_func=None, show_contracted=False, link_color_func=None, ax=None, above_threshold_color='b')"",)"
scipy,1.1.0,scipy.cluster.hierarchy.deque,cluster.hierarchy,deque,"Python Library Documentation: class deque in module collections

class deque(builtins.object)
 |  deque([iterable[, maxlen]]) --> deque object
 |  
 |  A list-like sequence optimized for data accesses near its endpoints.
 |  
 |  Methods defined here:
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __copy__(...)
 |      Return a shallow copy of a deque.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iadd__(self, value, /)
 |      Implement self+=value.
 |  
 |  __imul__(self, value, /)
 |      Implement self*=value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.n
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      Return state information for pickling.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(...)
 |      D.__reversed__() -- return a reverse iterator over the deque
 |  
 |  __rmul__(self, value, /)
 |      Return self*value.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __sizeof__(...)
 |      D.__sizeof__() -- size of D in memory, in bytes
 |  
 |  append(...)
 |      Add an element to the right side of the deque.
 |  
 |  appendleft(...)
 |      Add an element to the left side of the deque.
 |  
 |  clear(...)
 |      Remove all elements from the deque.
 |  
 |  copy(...)
 |      Return a shallow copy of a deque.
 |  
 |  count(...)
 |      D.count(value) -> integer -- return number of occurrences of value
 |  
 |  extend(...)
 |      Extend the right side of the deque with elements from the iterable
 |  
 |  extendleft(...)
 |      Extend the left side of the deque with elements from the iterable
 |  
 |  index(...)
 |      D.index(value, [start, [stop]]) -> integer -- return first index of value.
 |      Raises ValueError if the value is not present.
 |  
 |  insert(...)
 |      D.insert(index, object) -- insert object before index
 |  
 |  pop(...)
 |      Remove and return the rightmost element.
 |  
 |  popleft(...)
 |      Remove and return the leftmost element.
 |  
 |  remove(...)
 |      D.remove(value) -- remove first occurrence of value.
 |  
 |  reverse(...)
 |      D.reverse() -- reverse *IN PLACE*
 |  
 |  rotate(...)
 |      Rotate the deque n steps to the right (default n=1).  If n is negative, rotates left.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  maxlen
 |      maximum size of a deque or None if unbounded
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.cluster.hierarchy.deque,cluster.hierarchy,deque,"Python Library Documentation: class deque in module collections

class deque(builtins.object)
 |  deque([iterable[, maxlen]]) --> deque object
 |  
 |  A list-like sequence optimized for data accesses near its endpoints.
 |  
 |  Methods defined here:
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __copy__(...)
 |      Return a shallow copy of a deque.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iadd__(self, value, /)
 |      Implement self+=value.
 |  
 |  __imul__(self, value, /)
 |      Implement self*=value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.n
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      Return state information for pickling.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(...)
 |      D.__reversed__() -- return a reverse iterator over the deque
 |  
 |  __rmul__(self, value, /)
 |      Return self*value.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __sizeof__(...)
 |      D.__sizeof__() -- size of D in memory, in bytes
 |  
 |  append(...)
 |      Add an element to the right side of the deque.
 |  
 |  appendleft(...)
 |      Add an element to the left side of the deque.
 |  
 |  clear(...)
 |      Remove all elements from the deque.
 |  
 |  copy(...)
 |      Return a shallow copy of a deque.
 |  
 |  count(...)
 |      D.count(value) -> integer -- return number of occurrences of value
 |  
 |  extend(...)
 |      Extend the right side of the deque with elements from the iterable
 |  
 |  extendleft(...)
 |      Extend the left side of the deque with elements from the iterable
 |  
 |  index(...)
 |      D.index(value, [start, [stop]]) -> integer -- return first index of value.
 |      Raises ValueError if the value is not present.
 |  
 |  insert(...)
 |      D.insert(index, object) -- insert object before index
 |  
 |  pop(...)
 |      Remove and return the rightmost element.
 |  
 |  popleft(...)
 |      Remove and return the leftmost element.
 |  
 |  remove(...)
 |      D.remove(value) -- remove first occurrence of value.
 |  
 |  reverse(...)
 |      D.reverse() -- reverse *IN PLACE*
 |  
 |  rotate(...)
 |      Rotate the deque n steps to the right (default n=1).  If n is negative, rotates left.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  maxlen
 |      maximum size of a deque or None if unbounded
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.cluster.hierarchy.fcluster,cluster.hierarchy,fcluster,"Python Library Documentation: function fcluster in module scipy.cluster.hierarchy

fcluster(Z, t, criterion='inconsistent', depth=2, R=None, monocrit=None)
    Form flat clusters from the hierarchical clustering defined by
    the given linkage matrix.
    
    Parameters
    ----------
    Z : ndarray
        The hierarchical clustering encoded with the matrix returned
        by the `linkage` function.
    t : float
        The threshold to apply when forming flat clusters.
    criterion : str, optional
        The criterion to use in forming flat clusters. This can
        be any of the following values:
    
          ``inconsistent`` : 
              If a cluster node and all its
              descendants have an inconsistent value less than or equal
              to `t` then all its leaf descendants belong to the
              same flat cluster. When no non-singleton cluster meets
              this criterion, every node is assigned to its own
              cluster. (Default)
    
          ``distance`` : 
              Forms flat clusters so that the original
              observations in each flat cluster have no greater a
              cophenetic distance than `t`.
    
          ``maxclust`` : 
              Finds a minimum threshold ``r`` so that
              the cophenetic distance between any two original
              observations in the same flat cluster is no more than
              ``r`` and no more than `t` flat clusters are formed.
    
          ``monocrit`` : 
              Forms a flat cluster from a cluster node c
              with index i when ``monocrit[j] <= t``.
    
              For example, to threshold on the maximum mean distance
              as computed in the inconsistency matrix R with a
              threshold of 0.8 do::
    
                  MR = maxRstat(Z, R, 3)
                  cluster(Z, t=0.8, criterion='monocrit', monocrit=MR)
    
          ``maxclust_monocrit`` : 
              Forms a flat cluster from a
              non-singleton cluster node ``c`` when ``monocrit[i] <=
              r`` for all cluster indices ``i`` below and including
              ``c``. ``r`` is minimized such that no more than ``t``
              flat clusters are formed. monocrit must be
              monotonic. For example, to minimize the threshold t on
              maximum inconsistency values so that no more than 3 flat
              clusters are formed, do::
    
                  MI = maxinconsts(Z, R)
                  cluster(Z, t=3, criterion='maxclust_monocrit', monocrit=MI)
    
    depth : int, optional
        The maximum depth to perform the inconsistency calculation.
        It has no meaning for the other criteria. Default is 2.
    R : ndarray, optional
        The inconsistency matrix to use for the 'inconsistent'
        criterion. This matrix is computed if not provided.
    monocrit : ndarray, optional
        An array of length n-1. `monocrit[i]` is the
        statistics upon which non-singleton i is thresholded. The
        monocrit vector must be monotonic, i.e. given a node c with
        index i, for all node indices j corresponding to nodes
        below c, ``monocrit[i] >= monocrit[j]``.
    
    Returns
    -------
    fcluster : ndarray
        An array of length ``n``. ``T[i]`` is the flat cluster number to
        which original observation ``i`` belongs.
",function,"(""(Z, t, criterion='inconsistent', depth=2, R=None, monocrit=None)"",)",scipy,1.1.0,scipy.cluster.hierarchy.fcluster,cluster.hierarchy,fcluster,"Python Library Documentation: function fcluster in module scipy.cluster.hierarchy

fcluster(Z, t, criterion='inconsistent', depth=2, R=None, monocrit=None)
    Form flat clusters from the hierarchical clustering defined by
    the given linkage matrix.
    
    Parameters
    ----------
    Z : ndarray
        The hierarchical clustering encoded with the matrix returned
        by the `linkage` function.
    t : float
        The threshold to apply when forming flat clusters.
    criterion : str, optional
        The criterion to use in forming flat clusters. This can
        be any of the following values:
    
          ``inconsistent`` : 
              If a cluster node and all its
              descendants have an inconsistent value less than or equal
              to `t` then all its leaf descendants belong to the
              same flat cluster. When no non-singleton cluster meets
              this criterion, every node is assigned to its own
              cluster. (Default)
    
          ``distance`` : 
              Forms flat clusters so that the original
              observations in each flat cluster have no greater a
              cophenetic distance than `t`.
    
          ``maxclust`` : 
              Finds a minimum threshold ``r`` so that
              the cophenetic distance between any two original
              observations in the same flat cluster is no more than
              ``r`` and no more than `t` flat clusters are formed.
    
          ``monocrit`` : 
              Forms a flat cluster from a cluster node c
              with index i when ``monocrit[j] <= t``.
    
              For example, to threshold on the maximum mean distance
              as computed in the inconsistency matrix R with a
              threshold of 0.8 do::
    
                  MR = maxRstat(Z, R, 3)
                  cluster(Z, t=0.8, criterion='monocrit', monocrit=MR)
    
          ``maxclust_monocrit`` : 
              Forms a flat cluster from a
              non-singleton cluster node ``c`` when ``monocrit[i] <=
              r`` for all cluster indices ``i`` below and including
              ``c``. ``r`` is minimized such that no more than ``t``
              flat clusters are formed. monocrit must be
              monotonic. For example, to minimize the threshold t on
              maximum inconsistency values so that no more than 3 flat
              clusters are formed, do::
    
                  MI = maxinconsts(Z, R)
                  cluster(Z, t=3, criterion='maxclust_monocrit', monocrit=MI)
    
    depth : int, optional
        The maximum depth to perform the inconsistency calculation.
        It has no meaning for the other criteria. Default is 2.
    R : ndarray, optional
        The inconsistency matrix to use for the 'inconsistent'
        criterion. This matrix is computed if not provided.
    monocrit : ndarray, optional
        An array of length n-1. `monocrit[i]` is the
        statistics upon which non-singleton i is thresholded. The
        monocrit vector must be monotonic, i.e. given a node c with
        index i, for all node indices j corresponding to nodes
        below c, ``monocrit[i] >= monocrit[j]``.
    
    Returns
    -------
    fcluster : ndarray
        An array of length ``n``. ``T[i]`` is the flat cluster number to
        which original observation ``i`` belongs.
",function,"('Z', 't', 'criterion', 'depth', 'R', 'monocrit')","(nan, nan, 'inconsistent', 2, None, None)","(nan, nan, 'str', 'int', 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(Z, t, criterion='inconsistent', depth=2, R=None, monocrit=None)"",)"
scipy,1.1.0,scipy.cluster.hierarchy.fclusterdata,cluster.hierarchy,fclusterdata,"Python Library Documentation: function fclusterdata in module scipy.cluster.hierarchy

fclusterdata(X, t, criterion='inconsistent', metric='euclidean', depth=2, method='single', R=None)
    Cluster observation data using a given metric.
    
    Clusters the original observations in the n-by-m data
    matrix X (n observations in m dimensions), using the euclidean
    distance metric to calculate distances between original observations,
    performs hierarchical clustering using the single linkage algorithm,
    and forms flat clusters using the inconsistency method with `t` as the
    cut-off threshold.
    
    A one-dimensional array ``T`` of length ``n`` is returned. ``T[i]`` is
    the index of the flat cluster to which the original observation ``i``
    belongs.
    
    Parameters
    ----------
    X : (N, M) ndarray
        N by M data matrix with N observations in M dimensions.
    t : float
        The threshold to apply when forming flat clusters.
    criterion : str, optional
        Specifies the criterion for forming flat clusters.  Valid
        values are 'inconsistent' (default), 'distance', or 'maxclust'
        cluster formation algorithms. See `fcluster` for descriptions.
    metric : str, optional
        The distance metric for calculating pairwise distances. See
        ``distance.pdist`` for descriptions and linkage to verify
        compatibility with the linkage method.
    depth : int, optional
        The maximum depth for the inconsistency calculation. See
        `inconsistent` for more information.
    method : str, optional
        The linkage method to use (single, complete, average,
        weighted, median centroid, ward). See `linkage` for more
        information. Default is ""single"".
    R : ndarray, optional
        The inconsistency matrix. It will be computed if necessary
        if it is not passed.
    
    Returns
    -------
    fclusterdata : ndarray
        A vector of length n. T[i] is the flat cluster number to
        which original observation i belongs.
    
    See Also
    --------
    scipy.spatial.distance.pdist : pairwise distance metrics
    
    Notes
    -----
    This function is similar to the MATLAB function ``clusterdata``.
",function,"(""(X, t, criterion='inconsistent', metric='euclidean', depth=2, method='single', R=None)"",)",scipy,1.1.0,scipy.cluster.hierarchy.fclusterdata,cluster.hierarchy,fclusterdata,"Python Library Documentation: function fclusterdata in module scipy.cluster.hierarchy

fclusterdata(X, t, criterion='inconsistent', metric='euclidean', depth=2, method='single', R=None)
    Cluster observation data using a given metric.
    
    Clusters the original observations in the n-by-m data
    matrix X (n observations in m dimensions), using the euclidean
    distance metric to calculate distances between original observations,
    performs hierarchical clustering using the single linkage algorithm,
    and forms flat clusters using the inconsistency method with `t` as the
    cut-off threshold.
    
    A one-dimensional array ``T`` of length ``n`` is returned. ``T[i]`` is
    the index of the flat cluster to which the original observation ``i``
    belongs.
    
    Parameters
    ----------
    X : (N, M) ndarray
        N by M data matrix with N observations in M dimensions.
    t : float
        The threshold to apply when forming flat clusters.
    criterion : str, optional
        Specifies the criterion for forming flat clusters.  Valid
        values are 'inconsistent' (default), 'distance', or 'maxclust'
        cluster formation algorithms. See `fcluster` for descriptions.
    metric : str, optional
        The distance metric for calculating pairwise distances. See
        ``distance.pdist`` for descriptions and linkage to verify
        compatibility with the linkage method.
    depth : int, optional
        The maximum depth for the inconsistency calculation. See
        `inconsistent` for more information.
    method : str, optional
        The linkage method to use (single, complete, average,
        weighted, median centroid, ward). See `linkage` for more
        information. Default is ""single"".
    R : ndarray, optional
        The inconsistency matrix. It will be computed if necessary
        if it is not passed.
    
    Returns
    -------
    fclusterdata : ndarray
        A vector of length n. T[i] is the flat cluster number to
        which original observation i belongs.
    
    See Also
    --------
    scipy.spatial.distance.pdist : pairwise distance metrics
    
    Notes
    -----
    This function is similar to the MATLAB function ``clusterdata``.
",function,"('X', 't', 'criterion', 'metric', 'depth', 'method', 'R')","(nan, nan, 'inconsistent', 'euclidean', 2, 'single', None)","(nan, nan, 'str', 'str', 'int', 'str', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(X, t, criterion='inconsistent', metric='euclidean', depth=2, method='single', R=None)"",)"
scipy,1.1.0,scipy.cluster.hierarchy.from_mlab_linkage,cluster.hierarchy,from_mlab_linkage,"Python Library Documentation: function from_mlab_linkage in module scipy.cluster.hierarchy

from_mlab_linkage(Z)
    Convert a linkage matrix generated by MATLAB(TM) to a new
    linkage matrix compatible with this module.
    
    The conversion does two things:
    
     * the indices are converted from ``1..N`` to ``0..(N-1)`` form,
       and
    
     * a fourth column ``Z[:,3]`` is added where ``Z[i,3]`` represents the
       number of original observations (leaves) in the non-singleton
       cluster ``i``.
    
    This function is useful when loading in linkages from legacy data
    files generated by MATLAB.
    
    Parameters
    ----------
    Z : ndarray
        A linkage matrix generated by MATLAB(TM).
    
    Returns
    -------
    ZS : ndarray
        A linkage matrix compatible with ``scipy.cluster.hierarchy``.
",function,"('(Z)',)",scipy,1.1.0,scipy.cluster.hierarchy.from_mlab_linkage,cluster.hierarchy,from_mlab_linkage,"Python Library Documentation: function from_mlab_linkage in module scipy.cluster.hierarchy

from_mlab_linkage(Z)
    Convert a linkage matrix generated by MATLAB(TM) to a new
    linkage matrix compatible with this module.
    
    The conversion does two things:
    
     * the indices are converted from ``1..N`` to ``0..(N-1)`` form,
       and
    
     * a fourth column ``Z[:,3]`` is added where ``Z[i,3]`` represents the
       number of original observations (leaves) in the non-singleton
       cluster ``i``.
    
    This function is useful when loading in linkages from legacy data
    files generated by MATLAB.
    
    Parameters
    ----------
    Z : ndarray
        A linkage matrix generated by MATLAB(TM).
    
    Returns
    -------
    ZS : ndarray
        A linkage matrix compatible with ``scipy.cluster.hierarchy``.
",function,"('Z',)","(nan,)","(nan,)","('arg_info',)","('(Z)',)"
scipy,1.1.0,scipy.cluster.hierarchy.inconsistent,cluster.hierarchy,inconsistent,"Python Library Documentation: function inconsistent in module scipy.cluster.hierarchy

inconsistent(Z, d=2)
    Calculate inconsistency statistics on a linkage matrix.
    
    Parameters
    ----------
    Z : ndarray
        The :math:`(n-1)` by 4 matrix encoding the linkage (hierarchical
        clustering).  See `linkage` documentation for more information on its
        form.
    d : int, optional
        The number of links up to `d` levels below each non-singleton cluster.
    
    Returns
    -------
    R : ndarray
        A :math:`(n-1)` by 4 matrix where the ``i``'th row contains the link
        statistics for the non-singleton cluster ``i``. The link statistics are
        computed over the link heights for links :math:`d` levels below the
        cluster ``i``. ``R[i,0]`` and ``R[i,1]`` are the mean and standard
        deviation of the link heights, respectively; ``R[i,2]`` is the number
        of links included in the calculation; and ``R[i,3]`` is the
        inconsistency coefficient,
    
        .. math:: \frac{\mathtt{Z[i,2]} - \mathtt{R[i,0]}} {R[i,1]}
    
    Notes
    -----
    This function behaves similarly to the MATLAB(TM) ``inconsistent``
    function.
    
    Examples
    --------
    >>> from scipy.cluster.hierarchy import inconsistent, linkage
    >>> from matplotlib import pyplot as plt
    >>> X = [[i] for i in [2, 8, 0, 4, 1, 9, 9, 0]]
    >>> Z = linkage(X, 'ward')
    >>> print(Z)
    [[ 5.          6.          0.          2.        ]
     [ 2.          7.          0.          2.        ]
     [ 0.          4.          1.          2.        ]
     [ 1.          8.          1.15470054  3.        ]
     [ 9.         10.          2.12132034  4.        ]
     [ 3.         12.          4.11096096  5.        ]
     [11.         13.         14.07183949  8.        ]]
    >>> inconsistent(Z)
    array([[ 0.        ,  0.        ,  1.        ,  0.        ],
           [ 0.        ,  0.        ,  1.        ,  0.        ],
           [ 1.        ,  0.        ,  1.        ,  0.        ],
           [ 0.57735027,  0.81649658,  2.        ,  0.70710678],
           [ 1.04044011,  1.06123822,  3.        ,  1.01850858],
           [ 3.11614065,  1.40688837,  2.        ,  0.70710678],
           [ 6.44583366,  6.76770586,  3.        ,  1.12682288]])
",function,"('(Z, d=2)',)",scipy,1.1.0,scipy.cluster.hierarchy.inconsistent,cluster.hierarchy,inconsistent,"Python Library Documentation: function inconsistent in module scipy.cluster.hierarchy

inconsistent(Z, d=2)
    Calculate inconsistency statistics on a linkage matrix.
    
    Parameters
    ----------
    Z : ndarray
        The :math:`(n-1)` by 4 matrix encoding the linkage (hierarchical
        clustering).  See `linkage` documentation for more information on its
        form.
    d : int, optional
        The number of links up to `d` levels below each non-singleton cluster.
    
    Returns
    -------
    R : ndarray
        A :math:`(n-1)` by 4 matrix where the ``i``'th row contains the link
        statistics for the non-singleton cluster ``i``. The link statistics are
        computed over the link heights for links :math:`d` levels below the
        cluster ``i``. ``R[i,0]`` and ``R[i,1]`` are the mean and standard
        deviation of the link heights, respectively; ``R[i,2]`` is the number
        of links included in the calculation; and ``R[i,3]`` is the
        inconsistency coefficient,
    
        .. math:: \frac{\mathtt{Z[i,2]} - \mathtt{R[i,0]}} {R[i,1]}
    
    Notes
    -----
    This function behaves similarly to the MATLAB(TM) ``inconsistent``
    function.
    
    Examples
    --------
    >>> from scipy.cluster.hierarchy import inconsistent, linkage
    >>> from matplotlib import pyplot as plt
    >>> X = [[i] for i in [2, 8, 0, 4, 1, 9, 9, 0]]
    >>> Z = linkage(X, 'ward')
    >>> print(Z)
    [[ 5.          6.          0.          2.        ]
     [ 2.          7.          0.          2.        ]
     [ 0.          4.          1.          2.        ]
     [ 1.          8.          1.15470054  3.        ]
     [ 9.         10.          2.12132034  4.        ]
     [ 3.         12.          4.11096096  5.        ]
     [11.         13.         14.07183949  8.        ]]
    >>> inconsistent(Z)
    array([[ 0.        ,  0.        ,  1.        ,  0.        ],
           [ 0.        ,  0.        ,  1.        ,  0.        ],
           [ 1.        ,  0.        ,  1.        ,  0.        ],
           [ 0.57735027,  0.81649658,  2.        ,  0.70710678],
           [ 1.04044011,  1.06123822,  3.        ,  1.01850858],
           [ 3.11614065,  1.40688837,  2.        ,  0.70710678],
           [ 6.44583366,  6.76770586,  3.        ,  1.12682288]])
",function,"('Z', 'd')","(nan, 2)","(nan, 'int')","('arg_info', 'arg_info')","('(Z, d=2)',)"
scipy,1.1.0,scipy.cluster.hierarchy.is_isomorphic,cluster.hierarchy,is_isomorphic,"Python Library Documentation: function is_isomorphic in module scipy.cluster.hierarchy

is_isomorphic(T1, T2)
    Determine if two different cluster assignments are equivalent.
    
    Parameters
    ----------
    T1 : array_like
        An assignment of singleton cluster ids to flat cluster ids.
    T2 : array_like
        An assignment of singleton cluster ids to flat cluster ids.
    
    Returns
    -------
    b : bool
        Whether the flat cluster assignments `T1` and `T2` are
        equivalent.
",function,"('(T1, T2)',)",scipy,1.1.0,scipy.cluster.hierarchy.is_isomorphic,cluster.hierarchy,is_isomorphic,"Python Library Documentation: function is_isomorphic in module scipy.cluster.hierarchy

is_isomorphic(T1, T2)
    Determine if two different cluster assignments are equivalent.
    
    Parameters
    ----------
    T1 : array_like
        An assignment of singleton cluster ids to flat cluster ids.
    T2 : array_like
        An assignment of singleton cluster ids to flat cluster ids.
    
    Returns
    -------
    b : bool
        Whether the flat cluster assignments `T1` and `T2` are
        equivalent.
",function,"('T1', 'T2')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(T1, T2)',)"
scipy,1.1.0,scipy.cluster.hierarchy.is_monotonic,cluster.hierarchy,is_monotonic,"Python Library Documentation: function is_monotonic in module scipy.cluster.hierarchy

is_monotonic(Z)
    Return True if the linkage passed is monotonic.
    
    The linkage is monotonic if for every cluster :math:`s` and :math:`t`
    joined, the distance between them is no less than the distance
    between any previously joined clusters.
    
    Parameters
    ----------
    Z : ndarray
        The linkage matrix to check for monotonicity.
    
    Returns
    -------
    b : bool
        A boolean indicating whether the linkage is monotonic.
",function,"('(Z)',)",scipy,1.1.0,scipy.cluster.hierarchy.is_monotonic,cluster.hierarchy,is_monotonic,"Python Library Documentation: function is_monotonic in module scipy.cluster.hierarchy

is_monotonic(Z)
    Return True if the linkage passed is monotonic.
    
    The linkage is monotonic if for every cluster :math:`s` and :math:`t`
    joined, the distance between them is no less than the distance
    between any previously joined clusters.
    
    Parameters
    ----------
    Z : ndarray
        The linkage matrix to check for monotonicity.
    
    Returns
    -------
    b : bool
        A boolean indicating whether the linkage is monotonic.
",function,"('Z',)","(nan,)","(nan,)","('arg_info',)","('(Z)',)"
scipy,1.1.0,scipy.cluster.hierarchy.is_valid_im,cluster.hierarchy,is_valid_im,"Python Library Documentation: function is_valid_im in module scipy.cluster.hierarchy

is_valid_im(R, warning=False, throw=False, name=None)
    Return True if the inconsistency matrix passed is valid.
    
    It must be a :math:`n` by 4 array of doubles. The standard
    deviations ``R[:,1]`` must be nonnegative. The link counts
    ``R[:,2]`` must be positive and no greater than :math:`n-1`.
    
    Parameters
    ----------
    R : ndarray
        The inconsistency matrix to check for validity.
    warning : bool, optional
         When True, issues a Python warning if the linkage
         matrix passed is invalid.
    throw : bool, optional
         When True, throws a Python exception if the linkage
         matrix passed is invalid.
    name : str, optional
         This string refers to the variable name of the invalid
         linkage matrix.
    
    Returns
    -------
    b : bool
        True if the inconsistency matrix is valid.
",function,"('(R, warning=False, throw=False, name=None)',)",scipy,1.1.0,scipy.cluster.hierarchy.is_valid_im,cluster.hierarchy,is_valid_im,"Python Library Documentation: function is_valid_im in module scipy.cluster.hierarchy

is_valid_im(R, warning=False, throw=False, name=None)
    Return True if the inconsistency matrix passed is valid.
    
    It must be a :math:`n` by 4 array of doubles. The standard
    deviations ``R[:,1]`` must be nonnegative. The link counts
    ``R[:,2]`` must be positive and no greater than :math:`n-1`.
    
    Parameters
    ----------
    R : ndarray
        The inconsistency matrix to check for validity.
    warning : bool, optional
         When True, issues a Python warning if the linkage
         matrix passed is invalid.
    throw : bool, optional
         When True, throws a Python exception if the linkage
         matrix passed is invalid.
    name : str, optional
         This string refers to the variable name of the invalid
         linkage matrix.
    
    Returns
    -------
    b : bool
        True if the inconsistency matrix is valid.
",function,"('R', 'warning', 'throw', 'name')","(nan, False, False, None)","(nan, 'bool', 'bool', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(R, warning=False, throw=False, name=None)',)"
scipy,1.1.0,scipy.cluster.hierarchy.is_valid_linkage,cluster.hierarchy,is_valid_linkage,"Python Library Documentation: function is_valid_linkage in module scipy.cluster.hierarchy

is_valid_linkage(Z, warning=False, throw=False, name=None)
    Check the validity of a linkage matrix.
    
    A linkage matrix is valid if it is a two dimensional array (type double)
    with :math:`n` rows and 4 columns.  The first two columns must contain
    indices between 0 and :math:`2n-1`. For a given row ``i``, the following
    two expressions have to hold:
    
    .. math::
    
        0 \leq \mathtt{Z[i,0]} \leq i+n-1
        0 \leq Z[i,1] \leq i+n-1
    
    I.e. a cluster cannot join another cluster unless the cluster being joined
    has been generated.
    
    Parameters
    ----------
    Z : array_like
        Linkage matrix.
    warning : bool, optional
        When True, issues a Python warning if the linkage
        matrix passed is invalid.
    throw : bool, optional
        When True, throws a Python exception if the linkage
        matrix passed is invalid.
    name : str, optional
        This string refers to the variable name of the invalid
        linkage matrix.
    
    Returns
    -------
    b : bool
        True if the inconsistency matrix is valid.
",function,"('(Z, warning=False, throw=False, name=None)',)",scipy,1.1.0,scipy.cluster.hierarchy.is_valid_linkage,cluster.hierarchy,is_valid_linkage,"Python Library Documentation: function is_valid_linkage in module scipy.cluster.hierarchy

is_valid_linkage(Z, warning=False, throw=False, name=None)
    Check the validity of a linkage matrix.
    
    A linkage matrix is valid if it is a two dimensional array (type double)
    with :math:`n` rows and 4 columns.  The first two columns must contain
    indices between 0 and :math:`2n-1`. For a given row ``i``, the following
    two expressions have to hold:
    
    .. math::
    
        0 \leq \mathtt{Z[i,0]} \leq i+n-1
        0 \leq Z[i,1] \leq i+n-1
    
    I.e. a cluster cannot join another cluster unless the cluster being joined
    has been generated.
    
    Parameters
    ----------
    Z : array_like
        Linkage matrix.
    warning : bool, optional
        When True, issues a Python warning if the linkage
        matrix passed is invalid.
    throw : bool, optional
        When True, throws a Python exception if the linkage
        matrix passed is invalid.
    name : str, optional
        This string refers to the variable name of the invalid
        linkage matrix.
    
    Returns
    -------
    b : bool
        True if the inconsistency matrix is valid.
",function,"('Z', 'warning', 'throw', 'name')","(nan, False, False, None)","(nan, 'bool', 'bool', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(Z, warning=False, throw=False, name=None)',)"
scipy,1.1.0,scipy.cluster.hierarchy.leaders,cluster.hierarchy,leaders,"Python Library Documentation: function leaders in module scipy.cluster.hierarchy

leaders(Z, T)
    Return the root nodes in a hierarchical clustering.
    
    Returns the root nodes in a hierarchical clustering corresponding
    to a cut defined by a flat cluster assignment vector ``T``. See
    the ``fcluster`` function for more information on the format of ``T``.
    
    For each flat cluster :math:`j` of the :math:`k` flat clusters
    represented in the n-sized flat cluster assignment vector ``T``,
    this function finds the lowest cluster node :math:`i` in the linkage
    tree Z such that:
    
      * leaf descendents belong only to flat cluster j
        (i.e. ``T[p]==j`` for all :math:`p` in :math:`S(i)` where
        :math:`S(i)` is the set of leaf ids of leaf nodes descendent
        with cluster node :math:`i`)
    
      * there does not exist a leaf that is not descendent with
        :math:`i` that also belongs to cluster :math:`j`
        (i.e. ``T[q]!=j`` for all :math:`q` not in :math:`S(i)`).  If
        this condition is violated, ``T`` is not a valid cluster
        assignment vector, and an exception will be thrown.
    
    Parameters
    ----------
    Z : ndarray
        The hierarchical clustering encoded as a matrix. See
        `linkage` for more information.
    T : ndarray
        The flat cluster assignment vector.
    
    Returns
    -------
    L : ndarray
        The leader linkage node id's stored as a k-element 1-D array
        where ``k`` is the number of flat clusters found in ``T``.
    
        ``L[j]=i`` is the linkage cluster node id that is the
        leader of flat cluster with id M[j].  If ``i < n``, ``i``
        corresponds to an original observation, otherwise it
        corresponds to a non-singleton cluster.
    
        For example: if ``L[3]=2`` and ``M[3]=8``, the flat cluster with
        id 8's leader is linkage node 2.
    M : ndarray
        The leader linkage node id's stored as a k-element 1-D array where
        ``k`` is the number of flat clusters found in ``T``. This allows the
        set of flat cluster ids to be any arbitrary set of ``k`` integers.
",function,"('(Z, T)',)",scipy,1.1.0,scipy.cluster.hierarchy.leaders,cluster.hierarchy,leaders,"Python Library Documentation: function leaders in module scipy.cluster.hierarchy

leaders(Z, T)
    Return the root nodes in a hierarchical clustering.
    
    Returns the root nodes in a hierarchical clustering corresponding
    to a cut defined by a flat cluster assignment vector ``T``. See
    the ``fcluster`` function for more information on the format of ``T``.
    
    For each flat cluster :math:`j` of the :math:`k` flat clusters
    represented in the n-sized flat cluster assignment vector ``T``,
    this function finds the lowest cluster node :math:`i` in the linkage
    tree Z such that:
    
      * leaf descendents belong only to flat cluster j
        (i.e. ``T[p]==j`` for all :math:`p` in :math:`S(i)` where
        :math:`S(i)` is the set of leaf ids of leaf nodes descendent
        with cluster node :math:`i`)
    
      * there does not exist a leaf that is not descendent with
        :math:`i` that also belongs to cluster :math:`j`
        (i.e. ``T[q]!=j`` for all :math:`q` not in :math:`S(i)`).  If
        this condition is violated, ``T`` is not a valid cluster
        assignment vector, and an exception will be thrown.
    
    Parameters
    ----------
    Z : ndarray
        The hierarchical clustering encoded as a matrix. See
        `linkage` for more information.
    T : ndarray
        The flat cluster assignment vector.
    
    Returns
    -------
    L : ndarray
        The leader linkage node id's stored as a k-element 1-D array
        where ``k`` is the number of flat clusters found in ``T``.
    
        ``L[j]=i`` is the linkage cluster node id that is the
        leader of flat cluster with id M[j].  If ``i < n``, ``i``
        corresponds to an original observation, otherwise it
        corresponds to a non-singleton cluster.
    
        For example: if ``L[3]=2`` and ``M[3]=8``, the flat cluster with
        id 8's leader is linkage node 2.
    M : ndarray
        The leader linkage node id's stored as a k-element 1-D array where
        ``k`` is the number of flat clusters found in ``T``. This allows the
        set of flat cluster ids to be any arbitrary set of ``k`` integers.
",function,"('Z', 'T')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(Z, T)',)"
scipy,1.1.0,scipy.cluster.hierarchy.leaves_list,cluster.hierarchy,leaves_list,"Python Library Documentation: function leaves_list in module scipy.cluster.hierarchy

leaves_list(Z)
    Return a list of leaf node ids.
    
    The return corresponds to the observation vector index as it appears
    in the tree from left to right. Z is a linkage matrix.
    
    Parameters
    ----------
    Z : ndarray
        The hierarchical clustering encoded as a matrix.  `Z` is
        a linkage matrix.  See `linkage` for more information.
    
    Returns
    -------
    leaves_list : ndarray
        The list of leaf node ids.
",function,"('(Z)',)",scipy,1.1.0,scipy.cluster.hierarchy.leaves_list,cluster.hierarchy,leaves_list,"Python Library Documentation: function leaves_list in module scipy.cluster.hierarchy

leaves_list(Z)
    Return a list of leaf node ids.
    
    The return corresponds to the observation vector index as it appears
    in the tree from left to right. Z is a linkage matrix.
    
    Parameters
    ----------
    Z : ndarray
        The hierarchical clustering encoded as a matrix.  `Z` is
        a linkage matrix.  See `linkage` for more information.
    
    Returns
    -------
    leaves_list : ndarray
        The list of leaf node ids.
",function,"('Z',)","(nan,)","(nan,)","('arg_info',)","('(Z)',)"
scipy,1.1.0,scipy.cluster.hierarchy.linkage,cluster.hierarchy,linkage,"Python Library Documentation: function linkage in module scipy.cluster.hierarchy

linkage(y, method='single', metric='euclidean', optimal_ordering=False)
    Perform hierarchical/agglomerative clustering.
    
    The input y may be either a 1d condensed distance matrix
    or a 2d array of observation vectors.
    
    If y is a 1d condensed distance matrix,
    then y must be a :math:`\binom{n}{2}` sized
    vector where n is the number of original observations paired
    in the distance matrix. The behavior of this function is very
    similar to the MATLAB linkage function.
    
    A :math:`(n-1)` by 4 matrix ``Z`` is returned. At the
    :math:`i`-th iteration, clusters with indices ``Z[i, 0]`` and
    ``Z[i, 1]`` are combined to form cluster :math:`n + i`. A
    cluster with an index less than :math:`n` corresponds to one of
    the :math:`n` original observations. The distance between
    clusters ``Z[i, 0]`` and ``Z[i, 1]`` is given by ``Z[i, 2]``. The
    fourth value ``Z[i, 3]`` represents the number of original
    observations in the newly formed cluster.
    
    The following linkage methods are used to compute the distance
    :math:`d(s, t)` between two clusters :math:`s` and
    :math:`t`. The algorithm begins with a forest of clusters that
    have yet to be used in the hierarchy being formed. When two
    clusters :math:`s` and :math:`t` from this forest are combined
    into a single cluster :math:`u`, :math:`s` and :math:`t` are
    removed from the forest, and :math:`u` is added to the
    forest. When only one cluster remains in the forest, the algorithm
    stops, and this cluster becomes the root.
    
    A distance matrix is maintained at each iteration. The ``d[i,j]``
    entry corresponds to the distance between cluster :math:`i` and
    :math:`j` in the original forest.
    
    At each iteration, the algorithm must update the distance matrix
    to reflect the distance of the newly formed cluster u with the
    remaining clusters in the forest.
    
    Suppose there are :math:`|u|` original observations
    :math:`u[0], \ldots, u[|u|-1]` in cluster :math:`u` and
    :math:`|v|` original objects :math:`v[0], \ldots, v[|v|-1]` in
    cluster :math:`v`. Recall :math:`s` and :math:`t` are
    combined to form cluster :math:`u`. Let :math:`v` be any
    remaining cluster in the forest that is not :math:`u`.
    
    The following are methods for calculating the distance between the
    newly formed cluster :math:`u` and each :math:`v`.
    
      * method='single' assigns
    
        .. math::
           d(u,v) = \min(dist(u[i],v[j]))
    
        for all points :math:`i` in cluster :math:`u` and
        :math:`j` in cluster :math:`v`. This is also known as the
        Nearest Point Algorithm.
    
      * method='complete' assigns
    
        .. math::
           d(u, v) = \max(dist(u[i],v[j]))
    
        for all points :math:`i` in cluster u and :math:`j` in
        cluster :math:`v`. This is also known by the Farthest Point
        Algorithm or Voor Hees Algorithm.
    
      * method='average' assigns
    
        .. math::
           d(u,v) = \sum_{ij} \frac{d(u[i], v[j])}
                                   {(|u|*|v|)}
    
        for all points :math:`i` and :math:`j` where :math:`|u|`
        and :math:`|v|` are the cardinalities of clusters :math:`u`
        and :math:`v`, respectively. This is also called the UPGMA
        algorithm.
    
      * method='weighted' assigns
    
        .. math::
           d(u,v) = (dist(s,v) + dist(t,v))/2
    
        where cluster u was formed with cluster s and t and v
        is a remaining cluster in the forest. (also called WPGMA)
    
      * method='centroid' assigns
    
        .. math::
           dist(s,t) = ||c_s-c_t||_2
    
        where :math:`c_s` and :math:`c_t` are the centroids of
        clusters :math:`s` and :math:`t`, respectively. When two
        clusters :math:`s` and :math:`t` are combined into a new
        cluster :math:`u`, the new centroid is computed over all the
        original objects in clusters :math:`s` and :math:`t`. The
        distance then becomes the Euclidean distance between the
        centroid of :math:`u` and the centroid of a remaining cluster
        :math:`v` in the forest. This is also known as the UPGMC
        algorithm.
    
      * method='median' assigns :math:`d(s,t)` like the ``centroid``
        method. When two clusters :math:`s` and :math:`t` are combined
        into a new cluster :math:`u`, the average of centroids s and t
        give the new centroid :math:`u`. This is also known as the
        WPGMC algorithm.
    
      * method='ward' uses the Ward variance minimization algorithm.
        The new entry :math:`d(u,v)` is computed as follows,
    
        .. math::
    
           d(u,v) = \sqrt{\frac{|v|+|s|}
                               {T}d(v,s)^2
                        + \frac{|v|+|t|}
                               {T}d(v,t)^2
                        - \frac{|v|}
                               {T}d(s,t)^2}
    
        where :math:`u` is the newly joined cluster consisting of
        clusters :math:`s` and :math:`t`, :math:`v` is an unused
        cluster in the forest, :math:`T=|v|+|s|+|t|`, and
        :math:`|*|` is the cardinality of its argument. This is also
        known as the incremental algorithm.
    
    Warning: When the minimum distance pair in the forest is chosen, there
    may be two or more pairs with the same minimum distance. This
    implementation may choose a different minimum than the MATLAB
    version.
    
    Parameters
    ----------
    y : ndarray
        A condensed distance matrix. A condensed distance matrix
        is a flat array containing the upper triangular of the distance matrix.
        This is the form that ``pdist`` returns. Alternatively, a collection of
        :math:`m` observation vectors in :math:`n` dimensions may be passed as
        an :math:`m` by :math:`n` array. All elements of the condensed distance
        matrix must be finite, i.e. no NaNs or infs.
    method : str, optional
        The linkage algorithm to use. See the ``Linkage Methods`` section below
        for full descriptions.
    metric : str or function, optional
        The distance metric to use in the case that y is a collection of
        observation vectors; ignored otherwise. See the ``pdist``
        function for a list of valid distance metrics. A custom distance
        function can also be used.
    optimal_ordering : bool, optional
        If True, the linkage matrix will be reordered so that the distance
        between successive leaves is minimal. This results in a more intuitive
        tree structure when the data are visualized. defaults to False, because
        this algorithm can be slow, particularly on large datasets [2]_. See 
        also the `optimal_leaf_ordering` function.
        
        .. versionadded:: 1.0.0
    
    Returns
    -------
    Z : ndarray
        The hierarchical clustering encoded as a linkage matrix.
    
    Notes
    -----
    1. For method 'single' an optimized algorithm based on minimum spanning
       tree is implemented. It has time complexity :math:`O(n^2)`.
       For methods 'complete', 'average', 'weighted' and 'ward' an algorithm
       called nearest-neighbors chain is implemented. It also has time
       complexity :math:`O(n^2)`.
       For other methods a naive algorithm is implemented with :math:`O(n^3)`
       time complexity.
       All algorithms use :math:`O(n^2)` memory.
       Refer to [1]_ for details about the algorithms.
    2. Methods 'centroid', 'median' and 'ward' are correctly defined only if
       Euclidean pairwise metric is used. If `y` is passed as precomputed
       pairwise distances, then it is a user responsibility to assure that
       these distances are in fact Euclidean, otherwise the produced result
       will be incorrect.
    
    See Also
    --------
    scipy.spatial.distance.pdist : pairwise distance metrics
    
    References
    ----------
    .. [1] Daniel Mullner, ""Modern hierarchical, agglomerative clustering
           algorithms"", :arXiv:`1109.2378v1`.
    .. [2] Ziv Bar-Joseph, David K. Gifford, Tommi S. Jaakkola, ""Fast optimal
           leaf ordering for hierarchical clustering"", 2001. Bioinformatics
           https://doi.org/10.1093/bioinformatics/17.suppl_1.S22
    
    Examples
    --------
    >>> from scipy.cluster.hierarchy import dendrogram, linkage
    >>> from matplotlib import pyplot as plt
    >>> X = [[i] for i in [2, 8, 0, 4, 1, 9, 9, 0]]
    
    >>> Z = linkage(X, 'ward')
    >>> fig = plt.figure(figsize=(25, 10))
    >>> dn = dendrogram(Z)
    
    >>> Z = linkage(X, 'single')
    >>> fig = plt.figure(figsize=(25, 10))
    >>> dn = dendrogram(Z)
    >>> plt.show()
",function,"(""(y, method='single', metric='euclidean', optimal_ordering=False)"",)",scipy,1.1.0,scipy.cluster.hierarchy.linkage,cluster.hierarchy,linkage,"Python Library Documentation: function linkage in module scipy.cluster.hierarchy

linkage(y, method='single', metric='euclidean', optimal_ordering=False)
    Perform hierarchical/agglomerative clustering.
    
    The input y may be either a 1d condensed distance matrix
    or a 2d array of observation vectors.
    
    If y is a 1d condensed distance matrix,
    then y must be a :math:`\binom{n}{2}` sized
    vector where n is the number of original observations paired
    in the distance matrix. The behavior of this function is very
    similar to the MATLAB linkage function.
    
    A :math:`(n-1)` by 4 matrix ``Z`` is returned. At the
    :math:`i`-th iteration, clusters with indices ``Z[i, 0]`` and
    ``Z[i, 1]`` are combined to form cluster :math:`n + i`. A
    cluster with an index less than :math:`n` corresponds to one of
    the :math:`n` original observations. The distance between
    clusters ``Z[i, 0]`` and ``Z[i, 1]`` is given by ``Z[i, 2]``. The
    fourth value ``Z[i, 3]`` represents the number of original
    observations in the newly formed cluster.
    
    The following linkage methods are used to compute the distance
    :math:`d(s, t)` between two clusters :math:`s` and
    :math:`t`. The algorithm begins with a forest of clusters that
    have yet to be used in the hierarchy being formed. When two
    clusters :math:`s` and :math:`t` from this forest are combined
    into a single cluster :math:`u`, :math:`s` and :math:`t` are
    removed from the forest, and :math:`u` is added to the
    forest. When only one cluster remains in the forest, the algorithm
    stops, and this cluster becomes the root.
    
    A distance matrix is maintained at each iteration. The ``d[i,j]``
    entry corresponds to the distance between cluster :math:`i` and
    :math:`j` in the original forest.
    
    At each iteration, the algorithm must update the distance matrix
    to reflect the distance of the newly formed cluster u with the
    remaining clusters in the forest.
    
    Suppose there are :math:`|u|` original observations
    :math:`u[0], \ldots, u[|u|-1]` in cluster :math:`u` and
    :math:`|v|` original objects :math:`v[0], \ldots, v[|v|-1]` in
    cluster :math:`v`. Recall :math:`s` and :math:`t` are
    combined to form cluster :math:`u`. Let :math:`v` be any
    remaining cluster in the forest that is not :math:`u`.
    
    The following are methods for calculating the distance between the
    newly formed cluster :math:`u` and each :math:`v`.
    
      * method='single' assigns
    
        .. math::
           d(u,v) = \min(dist(u[i],v[j]))
    
        for all points :math:`i` in cluster :math:`u` and
        :math:`j` in cluster :math:`v`. This is also known as the
        Nearest Point Algorithm.
    
      * method='complete' assigns
    
        .. math::
           d(u, v) = \max(dist(u[i],v[j]))
    
        for all points :math:`i` in cluster u and :math:`j` in
        cluster :math:`v`. This is also known by the Farthest Point
        Algorithm or Voor Hees Algorithm.
    
      * method='average' assigns
    
        .. math::
           d(u,v) = \sum_{ij} \frac{d(u[i], v[j])}
                                   {(|u|*|v|)}
    
        for all points :math:`i` and :math:`j` where :math:`|u|`
        and :math:`|v|` are the cardinalities of clusters :math:`u`
        and :math:`v`, respectively. This is also called the UPGMA
        algorithm.
    
      * method='weighted' assigns
    
        .. math::
           d(u,v) = (dist(s,v) + dist(t,v))/2
    
        where cluster u was formed with cluster s and t and v
        is a remaining cluster in the forest. (also called WPGMA)
    
      * method='centroid' assigns
    
        .. math::
           dist(s,t) = ||c_s-c_t||_2
    
        where :math:`c_s` and :math:`c_t` are the centroids of
        clusters :math:`s` and :math:`t`, respectively. When two
        clusters :math:`s` and :math:`t` are combined into a new
        cluster :math:`u`, the new centroid is computed over all the
        original objects in clusters :math:`s` and :math:`t`. The
        distance then becomes the Euclidean distance between the
        centroid of :math:`u` and the centroid of a remaining cluster
        :math:`v` in the forest. This is also known as the UPGMC
        algorithm.
    
      * method='median' assigns :math:`d(s,t)` like the ``centroid``
        method. When two clusters :math:`s` and :math:`t` are combined
        into a new cluster :math:`u`, the average of centroids s and t
        give the new centroid :math:`u`. This is also known as the
        WPGMC algorithm.
    
      * method='ward' uses the Ward variance minimization algorithm.
        The new entry :math:`d(u,v)` is computed as follows,
    
        .. math::
    
           d(u,v) = \sqrt{\frac{|v|+|s|}
                               {T}d(v,s)^2
                        + \frac{|v|+|t|}
                               {T}d(v,t)^2
                        - \frac{|v|}
                               {T}d(s,t)^2}
    
        where :math:`u` is the newly joined cluster consisting of
        clusters :math:`s` and :math:`t`, :math:`v` is an unused
        cluster in the forest, :math:`T=|v|+|s|+|t|`, and
        :math:`|*|` is the cardinality of its argument. This is also
        known as the incremental algorithm.
    
    Warning: When the minimum distance pair in the forest is chosen, there
    may be two or more pairs with the same minimum distance. This
    implementation may choose a different minimum than the MATLAB
    version.
    
    Parameters
    ----------
    y : ndarray
        A condensed distance matrix. A condensed distance matrix
        is a flat array containing the upper triangular of the distance matrix.
        This is the form that ``pdist`` returns. Alternatively, a collection of
        :math:`m` observation vectors in :math:`n` dimensions may be passed as
        an :math:`m` by :math:`n` array. All elements of the condensed distance
        matrix must be finite, i.e. no NaNs or infs.
    method : str, optional
        The linkage algorithm to use. See the ``Linkage Methods`` section below
        for full descriptions.
    metric : str or function, optional
        The distance metric to use in the case that y is a collection of
        observation vectors; ignored otherwise. See the ``pdist``
        function for a list of valid distance metrics. A custom distance
        function can also be used.
    optimal_ordering : bool, optional
        If True, the linkage matrix will be reordered so that the distance
        between successive leaves is minimal. This results in a more intuitive
        tree structure when the data are visualized. defaults to False, because
        this algorithm can be slow, particularly on large datasets [2]_. See 
        also the `optimal_leaf_ordering` function.
        
        .. versionadded:: 1.0.0
    
    Returns
    -------
    Z : ndarray
        The hierarchical clustering encoded as a linkage matrix.
    
    Notes
    -----
    1. For method 'single' an optimized algorithm based on minimum spanning
       tree is implemented. It has time complexity :math:`O(n^2)`.
       For methods 'complete', 'average', 'weighted' and 'ward' an algorithm
       called nearest-neighbors chain is implemented. It also has time
       complexity :math:`O(n^2)`.
       For other methods a naive algorithm is implemented with :math:`O(n^3)`
       time complexity.
       All algorithms use :math:`O(n^2)` memory.
       Refer to [1]_ for details about the algorithms.
    2. Methods 'centroid', 'median' and 'ward' are correctly defined only if
       Euclidean pairwise metric is used. If `y` is passed as precomputed
       pairwise distances, then it is a user responsibility to assure that
       these distances are in fact Euclidean, otherwise the produced result
       will be incorrect.
    
    See Also
    --------
    scipy.spatial.distance.pdist : pairwise distance metrics
    
    References
    ----------
    .. [1] Daniel Mullner, ""Modern hierarchical, agglomerative clustering
           algorithms"", :arXiv:`1109.2378v1`.
    .. [2] Ziv Bar-Joseph, David K. Gifford, Tommi S. Jaakkola, ""Fast optimal
           leaf ordering for hierarchical clustering"", 2001. Bioinformatics
           https://doi.org/10.1093/bioinformatics/17.suppl_1.S22
    
    Examples
    --------
    >>> from scipy.cluster.hierarchy import dendrogram, linkage
    >>> from matplotlib import pyplot as plt
    >>> X = [[i] for i in [2, 8, 0, 4, 1, 9, 9, 0]]
    
    >>> Z = linkage(X, 'ward')
    >>> fig = plt.figure(figsize=(25, 10))
    >>> dn = dendrogram(Z)
    
    >>> Z = linkage(X, 'single')
    >>> fig = plt.figure(figsize=(25, 10))
    >>> dn = dendrogram(Z)
    >>> plt.show()
",function,"('y', 'method', 'metric', 'optimal_ordering')","(nan, 'single', 'euclidean', False)","(nan, 'str', 'str', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(y, method='single', metric='euclidean', optimal_ordering=False)"",)"
scipy,1.1.0,scipy.cluster.hierarchy.maxRstat,cluster.hierarchy,maxRstat,"Python Library Documentation: function maxRstat in module scipy.cluster.hierarchy

maxRstat(Z, R, i)
    Return the maximum statistic for each non-singleton cluster and its
    descendents.
    
    Parameters
    ----------
    Z : array_like
        The hierarchical clustering encoded as a matrix. See `linkage` for more
        information.
    R : array_like
        The inconsistency matrix.
    i : int
        The column of `R` to use as the statistic.
    
    Returns
    -------
    MR : ndarray
        Calculates the maximum statistic for the i'th column of the
        inconsistency matrix `R` for each non-singleton cluster
        node. ``MR[j]`` is the maximum over ``R[Q(j)-n, i]`` where
        ``Q(j)`` the set of all node ids corresponding to nodes below
        and including ``j``.
",function,"('(Z, R, i)',)",scipy,1.1.0,scipy.cluster.hierarchy.maxRstat,cluster.hierarchy,maxRstat,"Python Library Documentation: function maxRstat in module scipy.cluster.hierarchy

maxRstat(Z, R, i)
    Return the maximum statistic for each non-singleton cluster and its
    descendents.
    
    Parameters
    ----------
    Z : array_like
        The hierarchical clustering encoded as a matrix. See `linkage` for more
        information.
    R : array_like
        The inconsistency matrix.
    i : int
        The column of `R` to use as the statistic.
    
    Returns
    -------
    MR : ndarray
        Calculates the maximum statistic for the i'th column of the
        inconsistency matrix `R` for each non-singleton cluster
        node. ``MR[j]`` is the maximum over ``R[Q(j)-n, i]`` where
        ``Q(j)`` the set of all node ids corresponding to nodes below
        and including ``j``.
",function,"('Z', 'R', 'i')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(Z, R, i)',)"
scipy,1.1.0,scipy.cluster.hierarchy.maxdists,cluster.hierarchy,maxdists,"Python Library Documentation: function maxdists in module scipy.cluster.hierarchy

maxdists(Z)
    Return the maximum distance between any non-singleton cluster.
    
    Parameters
    ----------
    Z : ndarray
        The hierarchical clustering encoded as a matrix. See
        ``linkage`` for more information.
    
    Returns
    -------
    maxdists : ndarray
        A ``(n-1)`` sized numpy array of doubles; ``MD[i]`` represents
        the maximum distance between any cluster (including
        singletons) below and including the node with index i. More
        specifically, ``MD[i] = Z[Q(i)-n, 2].max()`` where ``Q(i)`` is the
        set of all node indices below and including node i.
",function,"('(Z)',)",scipy,1.1.0,scipy.cluster.hierarchy.maxdists,cluster.hierarchy,maxdists,"Python Library Documentation: function maxdists in module scipy.cluster.hierarchy

maxdists(Z)
    Return the maximum distance between any non-singleton cluster.
    
    Parameters
    ----------
    Z : ndarray
        The hierarchical clustering encoded as a matrix. See
        ``linkage`` for more information.
    
    Returns
    -------
    maxdists : ndarray
        A ``(n-1)`` sized numpy array of doubles; ``MD[i]`` represents
        the maximum distance between any cluster (including
        singletons) below and including the node with index i. More
        specifically, ``MD[i] = Z[Q(i)-n, 2].max()`` where ``Q(i)`` is the
        set of all node indices below and including node i.
",function,"('Z',)","(nan,)","(nan,)","('arg_info',)","('(Z)',)"
scipy,1.1.0,scipy.cluster.hierarchy.maxinconsts,cluster.hierarchy,maxinconsts,"Python Library Documentation: function maxinconsts in module scipy.cluster.hierarchy

maxinconsts(Z, R)
    Return the maximum inconsistency coefficient for each
    non-singleton cluster and its descendents.
    
    Parameters
    ----------
    Z : ndarray
        The hierarchical clustering encoded as a matrix. See
        `linkage` for more information.
    R : ndarray
        The inconsistency matrix.
    
    Returns
    -------
    MI : ndarray
        A monotonic ``(n-1)``-sized numpy array of doubles.
",function,"('(Z, R)',)",scipy,1.1.0,scipy.cluster.hierarchy.maxinconsts,cluster.hierarchy,maxinconsts,"Python Library Documentation: function maxinconsts in module scipy.cluster.hierarchy

maxinconsts(Z, R)
    Return the maximum inconsistency coefficient for each
    non-singleton cluster and its descendents.
    
    Parameters
    ----------
    Z : ndarray
        The hierarchical clustering encoded as a matrix. See
        `linkage` for more information.
    R : ndarray
        The inconsistency matrix.
    
    Returns
    -------
    MI : ndarray
        A monotonic ``(n-1)``-sized numpy array of doubles.
",function,"('Z', 'R')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(Z, R)',)"
scipy,1.1.0,scipy.cluster.hierarchy.median,cluster.hierarchy,median,"Python Library Documentation: function median in module scipy.cluster.hierarchy

median(y)
    Perform median/WPGMC linkage.
    
    See `linkage` for more information on the return structure
    and algorithm.
    
     The following are common calling conventions:
    
     1. ``Z = median(y)``
    
        Performs median/WPGMC linkage on the condensed distance matrix
        ``y``.  See ``linkage`` for more information on the return
        structure and algorithm.
    
     2. ``Z = median(X)``
    
        Performs median/WPGMC linkage on the observation matrix ``X``
        using Euclidean distance as the distance metric. See `linkage`
        for more information on the return structure and algorithm.
    
    Parameters
    ----------
    y : ndarray
        A condensed distance matrix. A condensed
        distance matrix is a flat array containing the upper
        triangular of the distance matrix. This is the form that
        ``pdist`` returns.  Alternatively, a collection of
        m observation vectors in n dimensions may be passed as
        a m by n array.
    
    Returns
    -------
    Z : ndarray
        The hierarchical clustering encoded as a linkage matrix.
    
    See Also
    --------
    linkage: for advanced creation of hierarchical clusterings.
    scipy.spatial.distance.pdist : pairwise distance metrics
",function,"('(y)',)",scipy,1.1.0,scipy.cluster.hierarchy.median,cluster.hierarchy,median,"Python Library Documentation: function median in module scipy.cluster.hierarchy

median(y)
    Perform median/WPGMC linkage.
    
    See `linkage` for more information on the return structure
    and algorithm.
    
     The following are common calling conventions:
    
     1. ``Z = median(y)``
    
        Performs median/WPGMC linkage on the condensed distance matrix
        ``y``.  See ``linkage`` for more information on the return
        structure and algorithm.
    
     2. ``Z = median(X)``
    
        Performs median/WPGMC linkage on the observation matrix ``X``
        using Euclidean distance as the distance metric. See `linkage`
        for more information on the return structure and algorithm.
    
    Parameters
    ----------
    y : ndarray
        A condensed distance matrix. A condensed
        distance matrix is a flat array containing the upper
        triangular of the distance matrix. This is the form that
        ``pdist`` returns.  Alternatively, a collection of
        m observation vectors in n dimensions may be passed as
        a m by n array.
    
    Returns
    -------
    Z : ndarray
        The hierarchical clustering encoded as a linkage matrix.
    
    See Also
    --------
    linkage: for advanced creation of hierarchical clusterings.
    scipy.spatial.distance.pdist : pairwise distance metrics
",function,"('y',)","(nan,)","(nan,)","('arg_info',)","('(y)',)"
scipy,1.1.0,scipy.cluster.hierarchy.num_obs_linkage,cluster.hierarchy,num_obs_linkage,"Python Library Documentation: function num_obs_linkage in module scipy.cluster.hierarchy

num_obs_linkage(Z)
    Return the number of original observations of the linkage matrix passed.
    
    Parameters
    ----------
    Z : ndarray
        The linkage matrix on which to perform the operation.
    
    Returns
    -------
    n : int
        The number of original observations in the linkage.
",function,"('(Z)',)",scipy,1.1.0,scipy.cluster.hierarchy.num_obs_linkage,cluster.hierarchy,num_obs_linkage,"Python Library Documentation: function num_obs_linkage in module scipy.cluster.hierarchy

num_obs_linkage(Z)
    Return the number of original observations of the linkage matrix passed.
    
    Parameters
    ----------
    Z : ndarray
        The linkage matrix on which to perform the operation.
    
    Returns
    -------
    n : int
        The number of original observations in the linkage.
",function,"('Z',)","(nan,)","(nan,)","('arg_info',)","('(Z)',)"
scipy,1.1.0,scipy.cluster.hierarchy.optimal_leaf_ordering,cluster.hierarchy,optimal_leaf_ordering,"Python Library Documentation: function optimal_leaf_ordering in module scipy.cluster.hierarchy

optimal_leaf_ordering(Z, y, metric='euclidean')
    Given a linkage matrix Z and distance, reorder the cut tree.
    
    Parameters
    ----------
    Z : ndarray
        The hierarchical clustering encoded as a linkage matrix. See
        `linkage` for more information on the return structure and
        algorithm.
    y : ndarray
        The condensed distance matrix from which Z was generated.
        Alternatively, a collection of m observation vectors in n
        dimensions may be passed as a m by n array.
    metric : str or function, optional
        The distance metric to use in the case that y is a collection of
        observation vectors; ignored otherwise. See the ``pdist``
        function for a list of valid distance metrics. A custom distance
        function can also be used.
    
    Returns
    -------
    Z_ordered : ndarray
        A copy of the linkage matrix Z, reordered to minimize the distance
        between adjacent leaves.
    
    Examples
    --------
    >>> from scipy.cluster import hierarchy
    >>> np.random.seed(23)
    >>> X = np.random.randn(10,10)
    >>> Z = hierarchy.ward(X)
    >>> hierarchy.leaves_list(Z)
    array([0, 5, 3, 9, 6, 8, 1, 4, 2, 7], dtype=int32)
    >>> hierarchy.leaves_list(hierarchy.optimal_leaf_ordering(Z, X))
    array([3, 9, 0, 5, 8, 2, 7, 4, 1, 6], dtype=int32)
",function,"(""(Z, y, metric='euclidean')"",)",scipy,1.1.0,scipy.cluster.hierarchy.optimal_leaf_ordering,cluster.hierarchy,optimal_leaf_ordering,"Python Library Documentation: function optimal_leaf_ordering in module scipy.cluster.hierarchy

optimal_leaf_ordering(Z, y, metric='euclidean')
    Given a linkage matrix Z and distance, reorder the cut tree.
    
    Parameters
    ----------
    Z : ndarray
        The hierarchical clustering encoded as a linkage matrix. See
        `linkage` for more information on the return structure and
        algorithm.
    y : ndarray
        The condensed distance matrix from which Z was generated.
        Alternatively, a collection of m observation vectors in n
        dimensions may be passed as a m by n array.
    metric : str or function, optional
        The distance metric to use in the case that y is a collection of
        observation vectors; ignored otherwise. See the ``pdist``
        function for a list of valid distance metrics. A custom distance
        function can also be used.
    
    Returns
    -------
    Z_ordered : ndarray
        A copy of the linkage matrix Z, reordered to minimize the distance
        between adjacent leaves.
    
    Examples
    --------
    >>> from scipy.cluster import hierarchy
    >>> np.random.seed(23)
    >>> X = np.random.randn(10,10)
    >>> Z = hierarchy.ward(X)
    >>> hierarchy.leaves_list(Z)
    array([0, 5, 3, 9, 6, 8, 1, 4, 2, 7], dtype=int32)
    >>> hierarchy.leaves_list(hierarchy.optimal_leaf_ordering(Z, X))
    array([3, 9, 0, 5, 8, 2, 7, 4, 1, 6], dtype=int32)
",function,"('Z', 'y', 'metric')","(nan, nan, 'euclidean')","(nan, nan, 'str')","('arg_info', 'arg_info', 'arg_info')","(""(Z, y, metric='euclidean')"",)"
scipy,1.1.0,scipy.cluster.hierarchy.set_link_color_palette,cluster.hierarchy,set_link_color_palette,"Python Library Documentation: function set_link_color_palette in module scipy.cluster.hierarchy

set_link_color_palette(palette)
    Set list of matplotlib color codes for use by dendrogram.
    
    Note that this palette is global (i.e. setting it once changes the colors
    for all subsequent calls to `dendrogram`) and that it affects only the
    the colors below ``color_threshold``.
    
    Note that `dendrogram` also accepts a custom coloring function through its
    ``link_color_func`` keyword, which is more flexible and non-global.
    
    Parameters
    ----------
    palette : list of str or None
        A list of matplotlib color codes.  The order of the color codes is the
        order in which the colors are cycled through when color thresholding in
        the dendrogram.
    
        If ``None``, resets the palette to its default (which is
        ``['g', 'r', 'c', 'm', 'y', 'k']``).
    
    Returns
    -------
    None
    
    See Also
    --------
    dendrogram
    
    Notes
    -----
    Ability to reset the palette with ``None`` added in Scipy 0.17.0.
    
    Examples
    --------
    >>> from scipy.cluster import hierarchy
    >>> ytdist = np.array([662., 877., 255., 412., 996., 295., 468., 268.,
    ...                    400., 754., 564., 138., 219., 869., 669.])
    >>> Z = hierarchy.linkage(ytdist, 'single')
    >>> dn = hierarchy.dendrogram(Z, no_plot=True)
    >>> dn['color_list']
    ['g', 'b', 'b', 'b', 'b']
    >>> hierarchy.set_link_color_palette(['c', 'm', 'y', 'k'])
    >>> dn = hierarchy.dendrogram(Z, no_plot=True)
    >>> dn['color_list']
    ['c', 'b', 'b', 'b', 'b']
    >>> dn = hierarchy.dendrogram(Z, no_plot=True, color_threshold=267,
    ...                           above_threshold_color='k')
    >>> dn['color_list']
    ['c', 'm', 'm', 'k', 'k']
    
    Now reset the color palette to its default:
    
    >>> hierarchy.set_link_color_palette(None)
",function,"('(palette)',)",scipy,1.1.0,scipy.cluster.hierarchy.set_link_color_palette,cluster.hierarchy,set_link_color_palette,"Python Library Documentation: function set_link_color_palette in module scipy.cluster.hierarchy

set_link_color_palette(palette)
    Set list of matplotlib color codes for use by dendrogram.
    
    Note that this palette is global (i.e. setting it once changes the colors
    for all subsequent calls to `dendrogram`) and that it affects only the
    the colors below ``color_threshold``.
    
    Note that `dendrogram` also accepts a custom coloring function through its
    ``link_color_func`` keyword, which is more flexible and non-global.
    
    Parameters
    ----------
    palette : list of str or None
        A list of matplotlib color codes.  The order of the color codes is the
        order in which the colors are cycled through when color thresholding in
        the dendrogram.
    
        If ``None``, resets the palette to its default (which is
        ``['g', 'r', 'c', 'm', 'y', 'k']``).
    
    Returns
    -------
    None
    
    See Also
    --------
    dendrogram
    
    Notes
    -----
    Ability to reset the palette with ``None`` added in Scipy 0.17.0.
    
    Examples
    --------
    >>> from scipy.cluster import hierarchy
    >>> ytdist = np.array([662., 877., 255., 412., 996., 295., 468., 268.,
    ...                    400., 754., 564., 138., 219., 869., 669.])
    >>> Z = hierarchy.linkage(ytdist, 'single')
    >>> dn = hierarchy.dendrogram(Z, no_plot=True)
    >>> dn['color_list']
    ['g', 'b', 'b', 'b', 'b']
    >>> hierarchy.set_link_color_palette(['c', 'm', 'y', 'k'])
    >>> dn = hierarchy.dendrogram(Z, no_plot=True)
    >>> dn['color_list']
    ['c', 'b', 'b', 'b', 'b']
    >>> dn = hierarchy.dendrogram(Z, no_plot=True, color_threshold=267,
    ...                           above_threshold_color='k')
    >>> dn['color_list']
    ['c', 'm', 'm', 'k', 'k']
    
    Now reset the color palette to its default:
    
    >>> hierarchy.set_link_color_palette(None)
",function,"('palette',)","(nan,)","(nan,)","('arg_info',)","('(palette)',)"
scipy,1.1.0,scipy.cluster.hierarchy.single,cluster.hierarchy,single,"Python Library Documentation: function single in module scipy.cluster.hierarchy

single(y)
    Perform single/min/nearest linkage on the condensed distance matrix ``y``.
    
    Parameters
    ----------
    y : ndarray
        The upper triangular of the distance matrix. The result of
        ``pdist`` is returned in this form.
    
    Returns
    -------
    Z : ndarray
        The linkage matrix.
    
    See Also
    --------
    linkage: for advanced creation of hierarchical clusterings.
    scipy.spatial.distance.pdist : pairwise distance metrics
",function,"('(y)',)",scipy,1.1.0,scipy.cluster.hierarchy.single,cluster.hierarchy,single,"Python Library Documentation: function single in module scipy.cluster.hierarchy

single(y)
    Perform single/min/nearest linkage on the condensed distance matrix ``y``.
    
    Parameters
    ----------
    y : ndarray
        The upper triangular of the distance matrix. The result of
        ``pdist`` is returned in this form.
    
    Returns
    -------
    Z : ndarray
        The linkage matrix.
    
    See Also
    --------
    linkage: for advanced creation of hierarchical clusterings.
    scipy.spatial.distance.pdist : pairwise distance metrics
",function,"('y',)","(nan,)","(nan,)","('arg_info',)","('(y)',)"
scipy,1.1.0,scipy.cluster.hierarchy.to_mlab_linkage,cluster.hierarchy,to_mlab_linkage,"Python Library Documentation: function to_mlab_linkage in module scipy.cluster.hierarchy

to_mlab_linkage(Z)
    Convert a linkage matrix to a MATLAB(TM) compatible one.
    
    Converts a linkage matrix ``Z`` generated by the linkage function
    of this module to a MATLAB(TM) compatible one. The return linkage
    matrix has the last column removed and the cluster indices are
    converted to ``1..N`` indexing.
    
    Parameters
    ----------
    Z : ndarray
        A linkage matrix generated by ``scipy.cluster.hierarchy``.
    
    Returns
    -------
    to_mlab_linkage : ndarray
        A linkage matrix compatible with MATLAB(TM)'s hierarchical
        clustering functions.
    
        The return linkage matrix has the last column removed
        and the cluster indices are converted to ``1..N`` indexing.
",function,"('(Z)',)",scipy,1.1.0,scipy.cluster.hierarchy.to_mlab_linkage,cluster.hierarchy,to_mlab_linkage,"Python Library Documentation: function to_mlab_linkage in module scipy.cluster.hierarchy

to_mlab_linkage(Z)
    Convert a linkage matrix to a MATLAB(TM) compatible one.
    
    Converts a linkage matrix ``Z`` generated by the linkage function
    of this module to a MATLAB(TM) compatible one. The return linkage
    matrix has the last column removed and the cluster indices are
    converted to ``1..N`` indexing.
    
    Parameters
    ----------
    Z : ndarray
        A linkage matrix generated by ``scipy.cluster.hierarchy``.
    
    Returns
    -------
    to_mlab_linkage : ndarray
        A linkage matrix compatible with MATLAB(TM)'s hierarchical
        clustering functions.
    
        The return linkage matrix has the last column removed
        and the cluster indices are converted to ``1..N`` indexing.
",function,"('Z',)","(nan,)","(nan,)","('arg_info',)","('(Z)',)"
scipy,1.1.0,scipy.cluster.hierarchy.to_tree,cluster.hierarchy,to_tree,"Python Library Documentation: function to_tree in module scipy.cluster.hierarchy

to_tree(Z, rd=False)
    Convert a linkage matrix into an easy-to-use tree object.
    
    The reference to the root `ClusterNode` object is returned (by default).
    
    Each `ClusterNode` object has a ``left``, ``right``, ``dist``, ``id``,
    and ``count`` attribute. The left and right attributes point to
    ClusterNode objects that were combined to generate the cluster.
    If both are None then the `ClusterNode` object is a leaf node, its count
    must be 1, and its distance is meaningless but set to 0.
    
    *Note: This function is provided for the convenience of the library
    user. ClusterNodes are not used as input to any of the functions in this
    library.*
    
    Parameters
    ----------
    Z : ndarray
        The linkage matrix in proper form (see the `linkage`
        function documentation).
    rd : bool, optional
        When False (default), a reference to the root `ClusterNode` object is
        returned.  Otherwise, a tuple ``(r, d)`` is returned. ``r`` is a
        reference to the root node while ``d`` is a list of `ClusterNode`
        objects - one per original entry in the linkage matrix plus entries
        for all clustering steps.  If a cluster id is
        less than the number of samples ``n`` in the data that the linkage
        matrix describes, then it corresponds to a singleton cluster (leaf
        node).
        See `linkage` for more information on the assignment of cluster ids
        to clusters.
    
    Returns
    -------
    tree : ClusterNode or tuple (ClusterNode, list of ClusterNode)
        If ``rd`` is False, a `ClusterNode`.
        If ``rd`` is True, a list of length ``2*n - 1``, with ``n`` the number
        of samples.  See the description of `rd` above for more details.
    
    See Also
    --------
    linkage, is_valid_linkage, ClusterNode
    
    Examples
    --------
    >>> from scipy.cluster import hierarchy
    >>> x = np.random.rand(10).reshape(5, 2)
    >>> Z = hierarchy.linkage(x)
    >>> hierarchy.to_tree(Z)
    <scipy.cluster.hierarchy.ClusterNode object at ...
    >>> rootnode, nodelist = hierarchy.to_tree(Z, rd=True)
    >>> rootnode
    <scipy.cluster.hierarchy.ClusterNode object at ...
    >>> len(nodelist)
    9
",function,"('(Z, rd=False)',)",scipy,1.1.0,scipy.cluster.hierarchy.to_tree,cluster.hierarchy,to_tree,"Python Library Documentation: function to_tree in module scipy.cluster.hierarchy

to_tree(Z, rd=False)
    Convert a linkage matrix into an easy-to-use tree object.
    
    The reference to the root `ClusterNode` object is returned (by default).
    
    Each `ClusterNode` object has a ``left``, ``right``, ``dist``, ``id``,
    and ``count`` attribute. The left and right attributes point to
    ClusterNode objects that were combined to generate the cluster.
    If both are None then the `ClusterNode` object is a leaf node, its count
    must be 1, and its distance is meaningless but set to 0.
    
    *Note: This function is provided for the convenience of the library
    user. ClusterNodes are not used as input to any of the functions in this
    library.*
    
    Parameters
    ----------
    Z : ndarray
        The linkage matrix in proper form (see the `linkage`
        function documentation).
    rd : bool, optional
        When False (default), a reference to the root `ClusterNode` object is
        returned.  Otherwise, a tuple ``(r, d)`` is returned. ``r`` is a
        reference to the root node while ``d`` is a list of `ClusterNode`
        objects - one per original entry in the linkage matrix plus entries
        for all clustering steps.  If a cluster id is
        less than the number of samples ``n`` in the data that the linkage
        matrix describes, then it corresponds to a singleton cluster (leaf
        node).
        See `linkage` for more information on the assignment of cluster ids
        to clusters.
    
    Returns
    -------
    tree : ClusterNode or tuple (ClusterNode, list of ClusterNode)
        If ``rd`` is False, a `ClusterNode`.
        If ``rd`` is True, a list of length ``2*n - 1``, with ``n`` the number
        of samples.  See the description of `rd` above for more details.
    
    See Also
    --------
    linkage, is_valid_linkage, ClusterNode
    
    Examples
    --------
    >>> from scipy.cluster import hierarchy
    >>> x = np.random.rand(10).reshape(5, 2)
    >>> Z = hierarchy.linkage(x)
    >>> hierarchy.to_tree(Z)
    <scipy.cluster.hierarchy.ClusterNode object at ...
    >>> rootnode, nodelist = hierarchy.to_tree(Z, rd=True)
    >>> rootnode
    <scipy.cluster.hierarchy.ClusterNode object at ...
    >>> len(nodelist)
    9
",function,"('Z', 'rd')","(nan, False)","(nan, 'bool')","('arg_info', 'arg_info')","('(Z, rd=False)',)"
scipy,1.1.0,scipy.cluster.hierarchy.ward,cluster.hierarchy,ward,"Python Library Documentation: function ward in module scipy.cluster.hierarchy

ward(y)
    Perform Ward's linkage on a condensed distance matrix.
    
    See `linkage` for more information on the return structure
    and algorithm.
    
    The following are common calling conventions:
    
    1. ``Z = ward(y)``
       Performs Ward's linkage on the condensed distance matrix ``y``.
    
    2. ``Z = ward(X)``
       Performs Ward's linkage on the observation matrix ``X`` using
       Euclidean distance as the distance metric.
    
    Parameters
    ----------
    y : ndarray
        A condensed distance matrix. A condensed
        distance matrix is a flat array containing the upper
        triangular of the distance matrix. This is the form that
        ``pdist`` returns.  Alternatively, a collection of
        m observation vectors in n dimensions may be passed as
        a m by n array.
    
    Returns
    -------
    Z : ndarray
        The hierarchical clustering encoded as a linkage matrix. See
        `linkage` for more information on the return structure and
        algorithm.
    
    See Also
    --------
    linkage: for advanced creation of hierarchical clusterings.
    scipy.spatial.distance.pdist : pairwise distance metrics
",function,"('(y)',)",scipy,1.1.0,scipy.cluster.hierarchy.ward,cluster.hierarchy,ward,"Python Library Documentation: function ward in module scipy.cluster.hierarchy

ward(y)
    Perform Ward's linkage on a condensed distance matrix.
    
    See `linkage` for more information on the return structure
    and algorithm.
    
    The following are common calling conventions:
    
    1. ``Z = ward(y)``
       Performs Ward's linkage on the condensed distance matrix ``y``.
    
    2. ``Z = ward(X)``
       Performs Ward's linkage on the observation matrix ``X`` using
       Euclidean distance as the distance metric.
    
    Parameters
    ----------
    y : ndarray
        A condensed distance matrix. A condensed
        distance matrix is a flat array containing the upper
        triangular of the distance matrix. This is the form that
        ``pdist`` returns.  Alternatively, a collection of
        m observation vectors in n dimensions may be passed as
        a m by n array.
    
    Returns
    -------
    Z : ndarray
        The hierarchical clustering encoded as a linkage matrix. See
        `linkage` for more information on the return structure and
        algorithm.
    
    See Also
    --------
    linkage: for advanced creation of hierarchical clusterings.
    scipy.spatial.distance.pdist : pairwise distance metrics
",function,"('y',)","(nan,)","(nan,)","('arg_info',)","('(y)',)"
scipy,1.1.0,scipy.cluster.hierarchy.weighted,cluster.hierarchy,weighted,"Python Library Documentation: function weighted in module scipy.cluster.hierarchy

weighted(y)
    Perform weighted/WPGMA linkage on the condensed distance matrix.
    
    See `linkage` for more information on the return
    structure and algorithm.
    
    Parameters
    ----------
    y : ndarray
        The upper triangular of the distance matrix. The result of
        ``pdist`` is returned in this form.
    
    Returns
    -------
    Z : ndarray
        A linkage matrix containing the hierarchical clustering. See
        `linkage` for more information on its structure.
    
    See Also
    --------
    linkage : for advanced creation of hierarchical clusterings.
    scipy.spatial.distance.pdist : pairwise distance metrics
",function,"('(y)',)",scipy,1.1.0,scipy.cluster.hierarchy.weighted,cluster.hierarchy,weighted,"Python Library Documentation: function weighted in module scipy.cluster.hierarchy

weighted(y)
    Perform weighted/WPGMA linkage on the condensed distance matrix.
    
    See `linkage` for more information on the return
    structure and algorithm.
    
    Parameters
    ----------
    y : ndarray
        The upper triangular of the distance matrix. The result of
        ``pdist`` is returned in this form.
    
    Returns
    -------
    Z : ndarray
        A linkage matrix containing the hierarchical clustering. See
        `linkage` for more information on its structure.
    
    See Also
    --------
    linkage : for advanced creation of hierarchical clusterings.
    scipy.spatial.distance.pdist : pairwise distance metrics
",function,"('y',)","(nan,)","(nan,)","('arg_info',)","('(y)',)"
scipy,1.1.0,scipy.cluster.hierarchy.xrange,cluster.hierarchy,range,"Python Library Documentation: class range in module builtins

class range(object)
 |  range(stop) -> range object
 |  range(start, stop[, step]) -> range object
 |  
 |  Return an object that produces a sequence of integers from start (inclusive)
 |  to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.
 |  start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.
 |  These are exactly the valid indices for a list of 4 elements.
 |  When step is given, it specifies the increment (or decrement).
 |  
 |  Methods defined here:
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(...)
 |      Return a reverse iterator.
 |  
 |  count(...)
 |      rangeobject.count(value) -> integer -- return number of occurrences of value
 |  
 |  index(...)
 |      rangeobject.index(value, [start, [stop]]) -> integer -- return index of value.
 |      Raise ValueError if the value is not present.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  start
 |  
 |  step
 |  
 |  stop
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.cluster.hierarchy.xrange,cluster.hierarchy,range,"Python Library Documentation: class range in module builtins

class range(object)
 |  range(stop) -> range object
 |  range(start, stop[, step]) -> range object
 |  
 |  Return an object that produces a sequence of integers from start (inclusive)
 |  to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.
 |  start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.
 |  These are exactly the valid indices for a list of 4 elements.
 |  When step is given, it specifies the increment (or decrement).
 |  
 |  Methods defined here:
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(...)
 |      Return a reverse iterator.
 |  
 |  count(...)
 |      rangeobject.count(value) -> integer -- return number of occurrences of value
 |  
 |  index(...)
 |      rangeobject.index(value, [start, [stop]]) -> integer -- return index of value.
 |      Raise ValueError if the value is not present.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  start
 |  
 |  step
 |  
 |  stop
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.cluster.vq.ClusterError,cluster.vq,ClusterError,"Python Library Documentation: class ClusterError in module scipy.cluster.vq

class ClusterError(builtins.Exception)
 |  Common base class for all non-exit exceptions.
 |  
 |  Method resolution order:
 |      ClusterError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.cluster.vq.ClusterError,cluster.vq,ClusterError,"Python Library Documentation: class ClusterError in module scipy.cluster.vq

class ClusterError(builtins.Exception)
 |  Common base class for all non-exit exceptions.
 |  
 |  Method resolution order:
 |      ClusterError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.cluster.vq._asarray_validated,cluster.vq,_asarray_validated,"Python Library Documentation: function _asarray_validated in module scipy._lib._util

_asarray_validated(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)
    Helper function for scipy argument validation.
    
    Many scipy linear algebra functions do support arbitrary array-like
    input arguments.  Examples of commonly unsupported inputs include
    matrices containing inf/nan, sparse matrix representations, and
    matrices with complicated elements.
    
    Parameters
    ----------
    a : array_like
        The array-like input.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default: True
    sparse_ok : bool, optional
        True if scipy sparse matrices are allowed.
    objects_ok : bool, optional
        True if arrays with dype('O') are allowed.
    mask_ok : bool, optional
        True if masked arrays are allowed.
    as_inexact : bool, optional
        True to convert the input array to a np.inexact dtype.
    
    Returns
    -------
    ret : ndarray
        The converted validated array.
",function,"('(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)',)",scipy,1.1.0,scipy.cluster.vq._asarray_validated,cluster.vq,_asarray_validated,"Python Library Documentation: function _asarray_validated in module scipy._lib._util

_asarray_validated(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)
    Helper function for scipy argument validation.
    
    Many scipy linear algebra functions do support arbitrary array-like
    input arguments.  Examples of commonly unsupported inputs include
    matrices containing inf/nan, sparse matrix representations, and
    matrices with complicated elements.
    
    Parameters
    ----------
    a : array_like
        The array-like input.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default: True
    sparse_ok : bool, optional
        True if scipy sparse matrices are allowed.
    objects_ok : bool, optional
        True if arrays with dype('O') are allowed.
    mask_ok : bool, optional
        True if masked arrays are allowed.
    as_inexact : bool, optional
        True to convert the input array to a np.inexact dtype.
    
    Returns
    -------
    ret : ndarray
        The converted validated array.
",function,"('a', 'check_finite', 'sparse_ok', 'objects_ok', 'mask_ok', 'as_inexact')","(nan, True, False, False, False, False)","(nan, 'bool', 'bool', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)',)"
scipy,1.1.0,scipy.cluster.vq._kmeans,cluster.vq,_kmeans,"Python Library Documentation: function _kmeans in module scipy.cluster.vq

_kmeans(obs, guess, thresh=1e-05)
    ""raw"" version of k-means.
    
    Returns
    -------
    code_book
        the lowest distortion codebook found.
    avg_dist
        the average distance a observation is from a code in the book.
        Lower means the code_book matches the data better.
    
    See Also
    --------
    kmeans : wrapper around k-means
    
    Examples
    --------
    Note: not whitened in this example.
    
    >>> from numpy import array
    >>> from scipy.cluster.vq import _kmeans
    >>> features  = array([[ 1.9,2.3],
    ...                    [ 1.5,2.5],
    ...                    [ 0.8,0.6],
    ...                    [ 0.4,1.8],
    ...                    [ 1.0,1.0]])
    >>> book = array((features[0],features[2]))
    >>> _kmeans(features,book)
    (array([[ 1.7       ,  2.4       ],
           [ 0.73333333,  1.13333333]]), 0.40563916697728591)
",function,"('(obs, guess, thresh=1e-05)',)",scipy,1.1.0,scipy.cluster.vq._kmeans,cluster.vq,_kmeans,"Python Library Documentation: function _kmeans in module scipy.cluster.vq

_kmeans(obs, guess, thresh=1e-05)
    ""raw"" version of k-means.
    
    Returns
    -------
    code_book
        the lowest distortion codebook found.
    avg_dist
        the average distance a observation is from a code in the book.
        Lower means the code_book matches the data better.
    
    See Also
    --------
    kmeans : wrapper around k-means
    
    Examples
    --------
    Note: not whitened in this example.
    
    >>> from numpy import array
    >>> from scipy.cluster.vq import _kmeans
    >>> features  = array([[ 1.9,2.3],
    ...                    [ 1.5,2.5],
    ...                    [ 0.8,0.6],
    ...                    [ 0.4,1.8],
    ...                    [ 1.0,1.0]])
    >>> book = array((features[0],features[2]))
    >>> _kmeans(features,book)
    (array([[ 1.7       ,  2.4       ],
           [ 0.73333333,  1.13333333]]), 0.40563916697728591)
",function,"('obs', 'guess', 'thresh')","(nan, nan, 1e-05)","(nan, nan, 'float')","('arg_info', 'arg_info', 'arg_info')","('(obs, guess, thresh=1e-05)',)"
scipy,1.1.0,scipy.cluster.vq._kpoints,cluster.vq,_kpoints,"Python Library Documentation: function _kpoints in module scipy.cluster.vq

_kpoints(data, k)
    Pick k points at random in data (one row = one observation).
    
    Parameters
    ----------
    data : ndarray
        Expect a rank 1 or 2 array. Rank 1 are assumed to describe one
        dimensional data, rank 2 multidimensional data, in which case one
        row is one observation.
    k : int
        Number of samples to generate.
",function,"('(data, k)',)",scipy,1.1.0,scipy.cluster.vq._kpoints,cluster.vq,_kpoints,"Python Library Documentation: function _kpoints in module scipy.cluster.vq

_kpoints(data, k)
    Pick k points at random in data (one row = one observation).
    
    Parameters
    ----------
    data : ndarray
        Expect a rank 1 or 2 array. Rank 1 are assumed to describe one
        dimensional data, rank 2 multidimensional data, in which case one
        row is one observation.
    k : int
        Number of samples to generate.
",function,"('data', 'k')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(data, k)',)"
scipy,1.1.0,scipy.cluster.vq._krandinit,cluster.vq,_krandinit,"Python Library Documentation: function _krandinit in module scipy.cluster.vq

_krandinit(data, k)
    Returns k samples of a random variable which parameters depend on data.
    
    More precisely, it returns k observations sampled from a Gaussian random
    variable which mean and covariances are the one estimated from data.
    
    Parameters
    ----------
    data : ndarray
        Expect a rank 1 or 2 array. Rank 1 are assumed to describe one
        dimensional data, rank 2 multidimensional data, in which case one
        row is one observation.
    k : int
        Number of samples to generate.
",function,"('(data, k)',)",scipy,1.1.0,scipy.cluster.vq._krandinit,cluster.vq,_krandinit,"Python Library Documentation: function _krandinit in module scipy.cluster.vq

_krandinit(data, k)
    Returns k samples of a random variable which parameters depend on data.
    
    More precisely, it returns k observations sampled from a Gaussian random
    variable which mean and covariances are the one estimated from data.
    
    Parameters
    ----------
    data : ndarray
        Expect a rank 1 or 2 array. Rank 1 are assumed to describe one
        dimensional data, rank 2 multidimensional data, in which case one
        row is one observation.
    k : int
        Number of samples to generate.
",function,"('data', 'k')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(data, k)',)"
scipy,1.1.0,scipy.cluster.vq._missing_raise,cluster.vq,_missing_raise,"Python Library Documentation: function _missing_raise in module scipy.cluster.vq

_missing_raise()
    raise a ClusterError when called.
",function,"('()',)",scipy,1.1.0,scipy.cluster.vq._missing_raise,cluster.vq,_missing_raise,"Python Library Documentation: function _missing_raise in module scipy.cluster.vq

_missing_raise()
    raise a ClusterError when called.
",function,(),(),(),(),"('()',)"
scipy,1.1.0,scipy.cluster.vq._missing_warn,cluster.vq,_missing_warn,"Python Library Documentation: function _missing_warn in module scipy.cluster.vq

_missing_warn()
    Print a warning when called.
",function,"('()',)",scipy,1.1.0,scipy.cluster.vq._missing_warn,cluster.vq,_missing_warn,"Python Library Documentation: function _missing_warn in module scipy.cluster.vq

_missing_warn()
    Print a warning when called.
",function,(),(),(),(),"('()',)"
scipy,1.1.0,scipy.cluster.vq.cdist,cluster.vq,cdist,"Python Library Documentation: function cdist in module scipy.spatial.distance

cdist(XA, XB, metric='euclidean', *args, **kwargs)
    Compute distance between each pair of the two collections of inputs.
    
    See Notes for common calling conventions.
    
    Parameters
    ----------
    XA : ndarray
        An :math:`m_A` by :math:`n` array of :math:`m_A`
        original observations in an :math:`n`-dimensional space.
        Inputs are converted to float type.
    XB : ndarray
        An :math:`m_B` by :math:`n` array of :math:`m_B`
        original observations in an :math:`n`-dimensional space.
        Inputs are converted to float type.
    metric : str or callable, optional
        The distance metric to use.  If a string, the distance function can be
        'braycurtis', 'canberra', 'chebyshev', 'cityblock', 'correlation',
        'cosine', 'dice', 'euclidean', 'hamming', 'jaccard', 'kulsinski',
        'mahalanobis', 'matching', 'minkowski', 'rogerstanimoto', 'russellrao',
        'seuclidean', 'sokalmichener', 'sokalsneath', 'sqeuclidean',
        'wminkowski', 'yule'.
    *args : tuple. Deprecated.
        Additional arguments should be passed as keyword arguments
    **kwargs : dict, optional
        Extra arguments to `metric`: refer to each metric documentation for a
        list of all possible arguments.
    
        Some possible arguments:
    
        p : scalar
        The p-norm to apply for Minkowski, weighted and unweighted.
        Default: 2.
    
        w : ndarray
        The weight vector for metrics that support weights (e.g., Minkowski).
    
        V : ndarray
        The variance vector for standardized Euclidean.
        Default: var(vstack([XA, XB]), axis=0, ddof=1)
    
        VI : ndarray
        The inverse of the covariance matrix for Mahalanobis.
        Default: inv(cov(vstack([XA, XB].T))).T
    
        out : ndarray
        The output array
        If not None, the distance matrix Y is stored in this array.
        Note: metric independent, it will become a regular keyword arg in a
        future scipy version
    
    Returns
    -------
    Y : ndarray
        A :math:`m_A` by :math:`m_B` distance matrix is returned.
        For each :math:`i` and :math:`j`, the metric
        ``dist(u=XA[i], v=XB[j])`` is computed and stored in the
        :math:`ij` th entry.
    
    Raises
    ------
    ValueError
        An exception is thrown if `XA` and `XB` do not have
        the same number of columns.
    
    Notes
    -----
    The following are common calling conventions:
    
    1. ``Y = cdist(XA, XB, 'euclidean')``
    
       Computes the distance between :math:`m` points using
       Euclidean distance (2-norm) as the distance metric between the
       points. The points are arranged as :math:`m`
       :math:`n`-dimensional row vectors in the matrix X.
    
    2. ``Y = cdist(XA, XB, 'minkowski', p=2.)``
    
       Computes the distances using the Minkowski distance
       :math:`||u-v||_p` (:math:`p`-norm) where :math:`p \geq 1`.
    
    3. ``Y = cdist(XA, XB, 'cityblock')``
    
       Computes the city block or Manhattan distance between the
       points.
    
    4. ``Y = cdist(XA, XB, 'seuclidean', V=None)``
    
       Computes the standardized Euclidean distance. The standardized
       Euclidean distance between two n-vectors ``u`` and ``v`` is
    
       .. math::
    
          \sqrt{\sum {(u_i-v_i)^2 / V[x_i]}}.
    
       V is the variance vector; V[i] is the variance computed over all
       the i'th components of the points. If not passed, it is
       automatically computed.
    
    5. ``Y = cdist(XA, XB, 'sqeuclidean')``
    
       Computes the squared Euclidean distance :math:`||u-v||_2^2` between
       the vectors.
    
    6. ``Y = cdist(XA, XB, 'cosine')``
    
       Computes the cosine distance between vectors u and v,
    
       .. math::
    
          1 - \frac{u \cdot v}
                   {{||u||}_2 {||v||}_2}
    
       where :math:`||*||_2` is the 2-norm of its argument ``*``, and
       :math:`u \cdot v` is the dot product of :math:`u` and :math:`v`.
    
    7. ``Y = cdist(XA, XB, 'correlation')``
    
       Computes the correlation distance between vectors u and v. This is
    
       .. math::
    
          1 - \frac{(u - \bar{u}) \cdot (v - \bar{v})}
                   {{||(u - \bar{u})||}_2 {||(v - \bar{v})||}_2}
    
       where :math:`\bar{v}` is the mean of the elements of vector v,
       and :math:`x \cdot y` is the dot product of :math:`x` and :math:`y`.
    
    
    8. ``Y = cdist(XA, XB, 'hamming')``
    
       Computes the normalized Hamming distance, or the proportion of
       those vector elements between two n-vectors ``u`` and ``v``
       which disagree. To save memory, the matrix ``X`` can be of type
       boolean.
    
    9. ``Y = cdist(XA, XB, 'jaccard')``
    
       Computes the Jaccard distance between the points. Given two
       vectors, ``u`` and ``v``, the Jaccard distance is the
       proportion of those elements ``u[i]`` and ``v[i]`` that
       disagree where at least one of them is non-zero.
    
    10. ``Y = cdist(XA, XB, 'chebyshev')``
    
       Computes the Chebyshev distance between the points. The
       Chebyshev distance between two n-vectors ``u`` and ``v`` is the
       maximum norm-1 distance between their respective elements. More
       precisely, the distance is given by
    
       .. math::
    
          d(u,v) = \max_i {|u_i-v_i|}.
    
    11. ``Y = cdist(XA, XB, 'canberra')``
    
       Computes the Canberra distance between the points. The
       Canberra distance between two points ``u`` and ``v`` is
    
       .. math::
    
         d(u,v) = \sum_i \frac{|u_i-v_i|}
                              {|u_i|+|v_i|}.
    
    12. ``Y = cdist(XA, XB, 'braycurtis')``
    
       Computes the Bray-Curtis distance between the points. The
       Bray-Curtis distance between two points ``u`` and ``v`` is
    
    
       .. math::
    
            d(u,v) = \frac{\sum_i (|u_i-v_i|)}
                          {\sum_i (|u_i+v_i|)}
    
    13. ``Y = cdist(XA, XB, 'mahalanobis', VI=None)``
    
       Computes the Mahalanobis distance between the points. The
       Mahalanobis distance between two points ``u`` and ``v`` is
       :math:`\sqrt{(u-v)(1/V)(u-v)^T}` where :math:`(1/V)` (the ``VI``
       variable) is the inverse covariance. If ``VI`` is not None,
       ``VI`` will be used as the inverse covariance matrix.
    
    14. ``Y = cdist(XA, XB, 'yule')``
    
       Computes the Yule distance between the boolean
       vectors. (see `yule` function documentation)
    
    15. ``Y = cdist(XA, XB, 'matching')``
    
       Synonym for 'hamming'.
    
    16. ``Y = cdist(XA, XB, 'dice')``
    
       Computes the Dice distance between the boolean vectors. (see
       `dice` function documentation)
    
    17. ``Y = cdist(XA, XB, 'kulsinski')``
    
       Computes the Kulsinski distance between the boolean
       vectors. (see `kulsinski` function documentation)
    
    18. ``Y = cdist(XA, XB, 'rogerstanimoto')``
    
       Computes the Rogers-Tanimoto distance between the boolean
       vectors. (see `rogerstanimoto` function documentation)
    
    19. ``Y = cdist(XA, XB, 'russellrao')``
    
       Computes the Russell-Rao distance between the boolean
       vectors. (see `russellrao` function documentation)
    
    20. ``Y = cdist(XA, XB, 'sokalmichener')``
    
       Computes the Sokal-Michener distance between the boolean
       vectors. (see `sokalmichener` function documentation)
    
    21. ``Y = cdist(XA, XB, 'sokalsneath')``
    
       Computes the Sokal-Sneath distance between the vectors. (see
       `sokalsneath` function documentation)
    
    
    22. ``Y = cdist(XA, XB, 'wminkowski', p=2., w=w)``
    
       Computes the weighted Minkowski distance between the
       vectors. (see `wminkowski` function documentation)
    
    23. ``Y = cdist(XA, XB, f)``
    
       Computes the distance between all pairs of vectors in X
       using the user supplied 2-arity function f. For example,
       Euclidean distance between the vectors could be computed
       as follows::
    
         dm = cdist(XA, XB, lambda u, v: np.sqrt(((u-v)**2).sum()))
    
       Note that you should avoid passing a reference to one of
       the distance functions defined in this library. For example,::
    
         dm = cdist(XA, XB, sokalsneath)
    
       would calculate the pair-wise distances between the vectors in
       X using the Python function `sokalsneath`. This would result in
       sokalsneath being called :math:`{n \choose 2}` times, which
       is inefficient. Instead, the optimized C version is more
       efficient, and we call it using the following syntax::
    
         dm = cdist(XA, XB, 'sokalsneath')
    
    Examples
    --------
    Find the Euclidean distances between four 2-D coordinates:
    
    >>> from scipy.spatial import distance
    >>> coords = [(35.0456, -85.2672),
    ...           (35.1174, -89.9711),
    ...           (35.9728, -83.9422),
    ...           (36.1667, -86.7833)]
    >>> distance.cdist(coords, coords, 'euclidean')
    array([[ 0.    ,  4.7044,  1.6172,  1.8856],
           [ 4.7044,  0.    ,  6.0893,  3.3561],
           [ 1.6172,  6.0893,  0.    ,  2.8477],
           [ 1.8856,  3.3561,  2.8477,  0.    ]])
    
    
    Find the Manhattan distance from a 3-D point to the corners of the unit
    cube:
    
    >>> a = np.array([[0, 0, 0],
    ...               [0, 0, 1],
    ...               [0, 1, 0],
    ...               [0, 1, 1],
    ...               [1, 0, 0],
    ...               [1, 0, 1],
    ...               [1, 1, 0],
    ...               [1, 1, 1]])
    >>> b = np.array([[ 0.1,  0.2,  0.4]])
    >>> distance.cdist(a, b, 'cityblock')
    array([[ 0.7],
           [ 0.9],
           [ 1.3],
           [ 1.5],
           [ 1.5],
           [ 1.7],
           [ 2.1],
           [ 2.3]])
",function,"(""(XA, XB, metric='euclidean', *args, **kwargs)"",)",scipy,1.1.0,scipy.cluster.vq.cdist,cluster.vq,cdist,"Python Library Documentation: function cdist in module scipy.spatial.distance

cdist(XA, XB, metric='euclidean', *args, **kwargs)
    Compute distance between each pair of the two collections of inputs.
    
    See Notes for common calling conventions.
    
    Parameters
    ----------
    XA : ndarray
        An :math:`m_A` by :math:`n` array of :math:`m_A`
        original observations in an :math:`n`-dimensional space.
        Inputs are converted to float type.
    XB : ndarray
        An :math:`m_B` by :math:`n` array of :math:`m_B`
        original observations in an :math:`n`-dimensional space.
        Inputs are converted to float type.
    metric : str or callable, optional
        The distance metric to use.  If a string, the distance function can be
        'braycurtis', 'canberra', 'chebyshev', 'cityblock', 'correlation',
        'cosine', 'dice', 'euclidean', 'hamming', 'jaccard', 'kulsinski',
        'mahalanobis', 'matching', 'minkowski', 'rogerstanimoto', 'russellrao',
        'seuclidean', 'sokalmichener', 'sokalsneath', 'sqeuclidean',
        'wminkowski', 'yule'.
    *args : tuple. Deprecated.
        Additional arguments should be passed as keyword arguments
    **kwargs : dict, optional
        Extra arguments to `metric`: refer to each metric documentation for a
        list of all possible arguments.
    
        Some possible arguments:
    
        p : scalar
        The p-norm to apply for Minkowski, weighted and unweighted.
        Default: 2.
    
        w : ndarray
        The weight vector for metrics that support weights (e.g., Minkowski).
    
        V : ndarray
        The variance vector for standardized Euclidean.
        Default: var(vstack([XA, XB]), axis=0, ddof=1)
    
        VI : ndarray
        The inverse of the covariance matrix for Mahalanobis.
        Default: inv(cov(vstack([XA, XB].T))).T
    
        out : ndarray
        The output array
        If not None, the distance matrix Y is stored in this array.
        Note: metric independent, it will become a regular keyword arg in a
        future scipy version
    
    Returns
    -------
    Y : ndarray
        A :math:`m_A` by :math:`m_B` distance matrix is returned.
        For each :math:`i` and :math:`j`, the metric
        ``dist(u=XA[i], v=XB[j])`` is computed and stored in the
        :math:`ij` th entry.
    
    Raises
    ------
    ValueError
        An exception is thrown if `XA` and `XB` do not have
        the same number of columns.
    
    Notes
    -----
    The following are common calling conventions:
    
    1. ``Y = cdist(XA, XB, 'euclidean')``
    
       Computes the distance between :math:`m` points using
       Euclidean distance (2-norm) as the distance metric between the
       points. The points are arranged as :math:`m`
       :math:`n`-dimensional row vectors in the matrix X.
    
    2. ``Y = cdist(XA, XB, 'minkowski', p=2.)``
    
       Computes the distances using the Minkowski distance
       :math:`||u-v||_p` (:math:`p`-norm) where :math:`p \geq 1`.
    
    3. ``Y = cdist(XA, XB, 'cityblock')``
    
       Computes the city block or Manhattan distance between the
       points.
    
    4. ``Y = cdist(XA, XB, 'seuclidean', V=None)``
    
       Computes the standardized Euclidean distance. The standardized
       Euclidean distance between two n-vectors ``u`` and ``v`` is
    
       .. math::
    
          \sqrt{\sum {(u_i-v_i)^2 / V[x_i]}}.
    
       V is the variance vector; V[i] is the variance computed over all
       the i'th components of the points. If not passed, it is
       automatically computed.
    
    5. ``Y = cdist(XA, XB, 'sqeuclidean')``
    
       Computes the squared Euclidean distance :math:`||u-v||_2^2` between
       the vectors.
    
    6. ``Y = cdist(XA, XB, 'cosine')``
    
       Computes the cosine distance between vectors u and v,
    
       .. math::
    
          1 - \frac{u \cdot v}
                   {{||u||}_2 {||v||}_2}
    
       where :math:`||*||_2` is the 2-norm of its argument ``*``, and
       :math:`u \cdot v` is the dot product of :math:`u` and :math:`v`.
    
    7. ``Y = cdist(XA, XB, 'correlation')``
    
       Computes the correlation distance between vectors u and v. This is
    
       .. math::
    
          1 - \frac{(u - \bar{u}) \cdot (v - \bar{v})}
                   {{||(u - \bar{u})||}_2 {||(v - \bar{v})||}_2}
    
       where :math:`\bar{v}` is the mean of the elements of vector v,
       and :math:`x \cdot y` is the dot product of :math:`x` and :math:`y`.
    
    
    8. ``Y = cdist(XA, XB, 'hamming')``
    
       Computes the normalized Hamming distance, or the proportion of
       those vector elements between two n-vectors ``u`` and ``v``
       which disagree. To save memory, the matrix ``X`` can be of type
       boolean.
    
    9. ``Y = cdist(XA, XB, 'jaccard')``
    
       Computes the Jaccard distance between the points. Given two
       vectors, ``u`` and ``v``, the Jaccard distance is the
       proportion of those elements ``u[i]`` and ``v[i]`` that
       disagree where at least one of them is non-zero.
    
    10. ``Y = cdist(XA, XB, 'chebyshev')``
    
       Computes the Chebyshev distance between the points. The
       Chebyshev distance between two n-vectors ``u`` and ``v`` is the
       maximum norm-1 distance between their respective elements. More
       precisely, the distance is given by
    
       .. math::
    
          d(u,v) = \max_i {|u_i-v_i|}.
    
    11. ``Y = cdist(XA, XB, 'canberra')``
    
       Computes the Canberra distance between the points. The
       Canberra distance between two points ``u`` and ``v`` is
    
       .. math::
    
         d(u,v) = \sum_i \frac{|u_i-v_i|}
                              {|u_i|+|v_i|}.
    
    12. ``Y = cdist(XA, XB, 'braycurtis')``
    
       Computes the Bray-Curtis distance between the points. The
       Bray-Curtis distance between two points ``u`` and ``v`` is
    
    
       .. math::
    
            d(u,v) = \frac{\sum_i (|u_i-v_i|)}
                          {\sum_i (|u_i+v_i|)}
    
    13. ``Y = cdist(XA, XB, 'mahalanobis', VI=None)``
    
       Computes the Mahalanobis distance between the points. The
       Mahalanobis distance between two points ``u`` and ``v`` is
       :math:`\sqrt{(u-v)(1/V)(u-v)^T}` where :math:`(1/V)` (the ``VI``
       variable) is the inverse covariance. If ``VI`` is not None,
       ``VI`` will be used as the inverse covariance matrix.
    
    14. ``Y = cdist(XA, XB, 'yule')``
    
       Computes the Yule distance between the boolean
       vectors. (see `yule` function documentation)
    
    15. ``Y = cdist(XA, XB, 'matching')``
    
       Synonym for 'hamming'.
    
    16. ``Y = cdist(XA, XB, 'dice')``
    
       Computes the Dice distance between the boolean vectors. (see
       `dice` function documentation)
    
    17. ``Y = cdist(XA, XB, 'kulsinski')``
    
       Computes the Kulsinski distance between the boolean
       vectors. (see `kulsinski` function documentation)
    
    18. ``Y = cdist(XA, XB, 'rogerstanimoto')``
    
       Computes the Rogers-Tanimoto distance between the boolean
       vectors. (see `rogerstanimoto` function documentation)
    
    19. ``Y = cdist(XA, XB, 'russellrao')``
    
       Computes the Russell-Rao distance between the boolean
       vectors. (see `russellrao` function documentation)
    
    20. ``Y = cdist(XA, XB, 'sokalmichener')``
    
       Computes the Sokal-Michener distance between the boolean
       vectors. (see `sokalmichener` function documentation)
    
    21. ``Y = cdist(XA, XB, 'sokalsneath')``
    
       Computes the Sokal-Sneath distance between the vectors. (see
       `sokalsneath` function documentation)
    
    
    22. ``Y = cdist(XA, XB, 'wminkowski', p=2., w=w)``
    
       Computes the weighted Minkowski distance between the
       vectors. (see `wminkowski` function documentation)
    
    23. ``Y = cdist(XA, XB, f)``
    
       Computes the distance between all pairs of vectors in X
       using the user supplied 2-arity function f. For example,
       Euclidean distance between the vectors could be computed
       as follows::
    
         dm = cdist(XA, XB, lambda u, v: np.sqrt(((u-v)**2).sum()))
    
       Note that you should avoid passing a reference to one of
       the distance functions defined in this library. For example,::
    
         dm = cdist(XA, XB, sokalsneath)
    
       would calculate the pair-wise distances between the vectors in
       X using the Python function `sokalsneath`. This would result in
       sokalsneath being called :math:`{n \choose 2}` times, which
       is inefficient. Instead, the optimized C version is more
       efficient, and we call it using the following syntax::
    
         dm = cdist(XA, XB, 'sokalsneath')
    
    Examples
    --------
    Find the Euclidean distances between four 2-D coordinates:
    
    >>> from scipy.spatial import distance
    >>> coords = [(35.0456, -85.2672),
    ...           (35.1174, -89.9711),
    ...           (35.9728, -83.9422),
    ...           (36.1667, -86.7833)]
    >>> distance.cdist(coords, coords, 'euclidean')
    array([[ 0.    ,  4.7044,  1.6172,  1.8856],
           [ 4.7044,  0.    ,  6.0893,  3.3561],
           [ 1.6172,  6.0893,  0.    ,  2.8477],
           [ 1.8856,  3.3561,  2.8477,  0.    ]])
    
    
    Find the Manhattan distance from a 3-D point to the corners of the unit
    cube:
    
    >>> a = np.array([[0, 0, 0],
    ...               [0, 0, 1],
    ...               [0, 1, 0],
    ...               [0, 1, 1],
    ...               [1, 0, 0],
    ...               [1, 0, 1],
    ...               [1, 1, 0],
    ...               [1, 1, 1]])
    >>> b = np.array([[ 0.1,  0.2,  0.4]])
    >>> distance.cdist(a, b, 'cityblock')
    array([[ 0.7],
           [ 0.9],
           [ 1.3],
           [ 1.5],
           [ 1.5],
           [ 1.7],
           [ 2.1],
           [ 2.3]])
",function,"('XA', 'XB', 'metric')","(nan, nan, 'euclidean')","(nan, nan, 'str')","('arg_info', 'arg_info', 'arg_info')","(""(XA, XB, metric='euclidean', *args, **kwargs)"",)"
scipy,1.1.0,scipy.cluster.vq.deque,cluster.vq,deque,"Python Library Documentation: class deque in module collections

class deque(builtins.object)
 |  deque([iterable[, maxlen]]) --> deque object
 |  
 |  A list-like sequence optimized for data accesses near its endpoints.
 |  
 |  Methods defined here:
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __copy__(...)
 |      Return a shallow copy of a deque.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iadd__(self, value, /)
 |      Implement self+=value.
 |  
 |  __imul__(self, value, /)
 |      Implement self*=value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.n
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      Return state information for pickling.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(...)
 |      D.__reversed__() -- return a reverse iterator over the deque
 |  
 |  __rmul__(self, value, /)
 |      Return self*value.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __sizeof__(...)
 |      D.__sizeof__() -- size of D in memory, in bytes
 |  
 |  append(...)
 |      Add an element to the right side of the deque.
 |  
 |  appendleft(...)
 |      Add an element to the left side of the deque.
 |  
 |  clear(...)
 |      Remove all elements from the deque.
 |  
 |  copy(...)
 |      Return a shallow copy of a deque.
 |  
 |  count(...)
 |      D.count(value) -> integer -- return number of occurrences of value
 |  
 |  extend(...)
 |      Extend the right side of the deque with elements from the iterable
 |  
 |  extendleft(...)
 |      Extend the left side of the deque with elements from the iterable
 |  
 |  index(...)
 |      D.index(value, [start, [stop]]) -> integer -- return first index of value.
 |      Raises ValueError if the value is not present.
 |  
 |  insert(...)
 |      D.insert(index, object) -- insert object before index
 |  
 |  pop(...)
 |      Remove and return the rightmost element.
 |  
 |  popleft(...)
 |      Remove and return the leftmost element.
 |  
 |  remove(...)
 |      D.remove(value) -- remove first occurrence of value.
 |  
 |  reverse(...)
 |      D.reverse() -- reverse *IN PLACE*
 |  
 |  rotate(...)
 |      Rotate the deque n steps to the right (default n=1).  If n is negative, rotates left.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  maxlen
 |      maximum size of a deque or None if unbounded
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.cluster.vq.deque,cluster.vq,deque,"Python Library Documentation: class deque in module collections

class deque(builtins.object)
 |  deque([iterable[, maxlen]]) --> deque object
 |  
 |  A list-like sequence optimized for data accesses near its endpoints.
 |  
 |  Methods defined here:
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __copy__(...)
 |      Return a shallow copy of a deque.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iadd__(self, value, /)
 |      Implement self+=value.
 |  
 |  __imul__(self, value, /)
 |      Implement self*=value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.n
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      Return state information for pickling.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(...)
 |      D.__reversed__() -- return a reverse iterator over the deque
 |  
 |  __rmul__(self, value, /)
 |      Return self*value.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __sizeof__(...)
 |      D.__sizeof__() -- size of D in memory, in bytes
 |  
 |  append(...)
 |      Add an element to the right side of the deque.
 |  
 |  appendleft(...)
 |      Add an element to the left side of the deque.
 |  
 |  clear(...)
 |      Remove all elements from the deque.
 |  
 |  copy(...)
 |      Return a shallow copy of a deque.
 |  
 |  count(...)
 |      D.count(value) -> integer -- return number of occurrences of value
 |  
 |  extend(...)
 |      Extend the right side of the deque with elements from the iterable
 |  
 |  extendleft(...)
 |      Extend the left side of the deque with elements from the iterable
 |  
 |  index(...)
 |      D.index(value, [start, [stop]]) -> integer -- return first index of value.
 |      Raises ValueError if the value is not present.
 |  
 |  insert(...)
 |      D.insert(index, object) -- insert object before index
 |  
 |  pop(...)
 |      Remove and return the rightmost element.
 |  
 |  popleft(...)
 |      Remove and return the leftmost element.
 |  
 |  remove(...)
 |      D.remove(value) -- remove first occurrence of value.
 |  
 |  reverse(...)
 |      D.reverse() -- reverse *IN PLACE*
 |  
 |  rotate(...)
 |      Rotate the deque n steps to the right (default n=1).  If n is negative, rotates left.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  maxlen
 |      maximum size of a deque or None if unbounded
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.cluster.vq.kmeans,cluster.vq,kmeans,"Python Library Documentation: function kmeans in module scipy.cluster.vq

kmeans(obs, k_or_guess, iter=20, thresh=1e-05, check_finite=True)
    Performs k-means on a set of observation vectors forming k clusters.
    
    The k-means algorithm adjusts the centroids until sufficient
    progress cannot be made, i.e. the change in distortion since
    the last iteration is less than some threshold. This yields
    a code book mapping centroids to codes and vice versa.
    
    Distortion is defined as the sum of the squared differences
    between the observations and the corresponding centroid.
    
    Parameters
    ----------
    obs : ndarray
       Each row of the M by N array is an observation vector. The
       columns are the features seen during each observation.
       The features must be whitened first with the `whiten` function.
    
    k_or_guess : int or ndarray
       The number of centroids to generate. A code is assigned to
       each centroid, which is also the row index of the centroid
       in the code_book matrix generated.
    
       The initial k centroids are chosen by randomly selecting
       observations from the observation matrix. Alternatively,
       passing a k by N array specifies the initial k centroids.
    
    iter : int, optional
       The number of times to run k-means, returning the codebook
       with the lowest distortion. This argument is ignored if
       initial centroids are specified with an array for the
       ``k_or_guess`` parameter. This parameter does not represent the
       number of iterations of the k-means algorithm.
    
    thresh : float, optional
       Terminates the k-means algorithm if the change in
       distortion since the last k-means iteration is less than
       or equal to thresh.
    
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default: True
    
    Returns
    -------
    codebook : ndarray
       A k by N array of k centroids. The i'th centroid
       codebook[i] is represented with the code i. The centroids
       and codes generated represent the lowest distortion seen,
       not necessarily the globally minimal distortion.
    
    distortion : float
       The distortion between the observations passed and the
       centroids generated.
    
    See Also
    --------
    kmeans2 : a different implementation of k-means clustering
       with more methods for generating initial centroids but without
       using a distortion change threshold as a stopping criterion.
    
    whiten : must be called prior to passing an observation matrix
       to kmeans.
    
    Examples
    --------
    >>> from numpy import array
    >>> from scipy.cluster.vq import vq, kmeans, whiten
    >>> import matplotlib.pyplot as plt
    >>> features  = array([[ 1.9,2.3],
    ...                    [ 1.5,2.5],
    ...                    [ 0.8,0.6],
    ...                    [ 0.4,1.8],
    ...                    [ 0.1,0.1],
    ...                    [ 0.2,1.8],
    ...                    [ 2.0,0.5],
    ...                    [ 0.3,1.5],
    ...                    [ 1.0,1.0]])
    >>> whitened = whiten(features)
    >>> book = np.array((whitened[0],whitened[2]))
    >>> kmeans(whitened,book)
    (array([[ 2.3110306 ,  2.86287398],    # random
           [ 0.93218041,  1.24398691]]), 0.85684700941625547)
    
    >>> from numpy import random
    >>> random.seed((1000,2000))
    >>> codes = 3
    >>> kmeans(whitened,codes)
    (array([[ 2.3110306 ,  2.86287398],    # random
           [ 1.32544402,  0.65607529],
           [ 0.40782893,  2.02786907]]), 0.5196582527686241)
    
    >>> # Create 50 datapoints in two clusters a and b
    >>> pts = 50
    >>> a = np.random.multivariate_normal([0, 0], [[4, 1], [1, 4]], size=pts)
    >>> b = np.random.multivariate_normal([30, 10],
    ...                                   [[10, 2], [2, 1]],
    ...                                   size=pts)
    >>> features = np.concatenate((a, b))
    >>> # Whiten data
    >>> whitened = whiten(features)
    >>> # Find 2 clusters in the data
    >>> codebook, distortion = kmeans(whitened, 2)
    >>> # Plot whitened data and cluster centers in red
    >>> plt.scatter(whitened[:, 0], whitened[:, 1])
    >>> plt.scatter(codebook[:, 0], codebook[:, 1], c='r')
    >>> plt.show()
",function,"('(obs, k_or_guess, iter=20, thresh=1e-05, check_finite=True)',)",scipy,1.1.0,scipy.cluster.vq.kmeans,cluster.vq,kmeans,"Python Library Documentation: function kmeans in module scipy.cluster.vq

kmeans(obs, k_or_guess, iter=20, thresh=1e-05, check_finite=True)
    Performs k-means on a set of observation vectors forming k clusters.
    
    The k-means algorithm adjusts the centroids until sufficient
    progress cannot be made, i.e. the change in distortion since
    the last iteration is less than some threshold. This yields
    a code book mapping centroids to codes and vice versa.
    
    Distortion is defined as the sum of the squared differences
    between the observations and the corresponding centroid.
    
    Parameters
    ----------
    obs : ndarray
       Each row of the M by N array is an observation vector. The
       columns are the features seen during each observation.
       The features must be whitened first with the `whiten` function.
    
    k_or_guess : int or ndarray
       The number of centroids to generate. A code is assigned to
       each centroid, which is also the row index of the centroid
       in the code_book matrix generated.
    
       The initial k centroids are chosen by randomly selecting
       observations from the observation matrix. Alternatively,
       passing a k by N array specifies the initial k centroids.
    
    iter : int, optional
       The number of times to run k-means, returning the codebook
       with the lowest distortion. This argument is ignored if
       initial centroids are specified with an array for the
       ``k_or_guess`` parameter. This parameter does not represent the
       number of iterations of the k-means algorithm.
    
    thresh : float, optional
       Terminates the k-means algorithm if the change in
       distortion since the last k-means iteration is less than
       or equal to thresh.
    
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default: True
    
    Returns
    -------
    codebook : ndarray
       A k by N array of k centroids. The i'th centroid
       codebook[i] is represented with the code i. The centroids
       and codes generated represent the lowest distortion seen,
       not necessarily the globally minimal distortion.
    
    distortion : float
       The distortion between the observations passed and the
       centroids generated.
    
    See Also
    --------
    kmeans2 : a different implementation of k-means clustering
       with more methods for generating initial centroids but without
       using a distortion change threshold as a stopping criterion.
    
    whiten : must be called prior to passing an observation matrix
       to kmeans.
    
    Examples
    --------
    >>> from numpy import array
    >>> from scipy.cluster.vq import vq, kmeans, whiten
    >>> import matplotlib.pyplot as plt
    >>> features  = array([[ 1.9,2.3],
    ...                    [ 1.5,2.5],
    ...                    [ 0.8,0.6],
    ...                    [ 0.4,1.8],
    ...                    [ 0.1,0.1],
    ...                    [ 0.2,1.8],
    ...                    [ 2.0,0.5],
    ...                    [ 0.3,1.5],
    ...                    [ 1.0,1.0]])
    >>> whitened = whiten(features)
    >>> book = np.array((whitened[0],whitened[2]))
    >>> kmeans(whitened,book)
    (array([[ 2.3110306 ,  2.86287398],    # random
           [ 0.93218041,  1.24398691]]), 0.85684700941625547)
    
    >>> from numpy import random
    >>> random.seed((1000,2000))
    >>> codes = 3
    >>> kmeans(whitened,codes)
    (array([[ 2.3110306 ,  2.86287398],    # random
           [ 1.32544402,  0.65607529],
           [ 0.40782893,  2.02786907]]), 0.5196582527686241)
    
    >>> # Create 50 datapoints in two clusters a and b
    >>> pts = 50
    >>> a = np.random.multivariate_normal([0, 0], [[4, 1], [1, 4]], size=pts)
    >>> b = np.random.multivariate_normal([30, 10],
    ...                                   [[10, 2], [2, 1]],
    ...                                   size=pts)
    >>> features = np.concatenate((a, b))
    >>> # Whiten data
    >>> whitened = whiten(features)
    >>> # Find 2 clusters in the data
    >>> codebook, distortion = kmeans(whitened, 2)
    >>> # Plot whitened data and cluster centers in red
    >>> plt.scatter(whitened[:, 0], whitened[:, 1])
    >>> plt.scatter(codebook[:, 0], codebook[:, 1], c='r')
    >>> plt.show()
",function,"('obs', 'k_or_guess', 'iter', 'thresh', 'check_finite')","(nan, nan, 20, 1e-05, True)","(nan, nan, 'int', 'float', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(obs, k_or_guess, iter=20, thresh=1e-05, check_finite=True)',)"
scipy,1.1.0,scipy.cluster.vq.kmeans2,cluster.vq,kmeans2,"Python Library Documentation: function kmeans2 in module scipy.cluster.vq

kmeans2(data, k, iter=10, thresh=1e-05, minit='random', missing='warn', check_finite=True)
    Classify a set of observations into k clusters using the k-means algorithm.
    
    The algorithm attempts to minimize the Euclidian distance between
    observations and centroids. Several initialization methods are
    included.
    
    Parameters
    ----------
    data : ndarray
        A 'M' by 'N' array of 'M' observations in 'N' dimensions or a length
        'M' array of 'M' one-dimensional observations.
    k : int or ndarray
        The number of clusters to form as well as the number of
        centroids to generate. If `minit` initialization string is
        'matrix', or if a ndarray is given instead, it is
        interpreted as initial cluster to use instead.
    iter : int, optional
        Number of iterations of the k-means algorithm to run. Note
        that this differs in meaning from the iters parameter to
        the kmeans function.
    thresh : float, optional
        (not used yet)
    minit : str, optional
        Method for initialization. Available methods are 'random',
        'points', and 'matrix':
    
        'random': generate k centroids from a Gaussian with mean and
        variance estimated from the data.
    
        'points': choose k observations (rows) at random from data for
        the initial centroids.
    
        'matrix': interpret the k parameter as a k by M (or length k
        array for one-dimensional data) array of initial centroids.
    missing : str, optional
        Method to deal with empty clusters. Available methods are
        'warn' and 'raise':
    
        'warn': give a warning and continue.
    
        'raise': raise an ClusterError and terminate the algorithm.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default: True
    
    Returns
    -------
    centroid : ndarray
        A 'k' by 'N' array of centroids found at the last iteration of
        k-means.
    label : ndarray
        label[i] is the code or index of the centroid the
        i'th observation is closest to.
",function,"(""(data, k, iter=10, thresh=1e-05, minit='random', missing='warn', check_finite=True)"",)",scipy,1.1.0,scipy.cluster.vq.kmeans2,cluster.vq,kmeans2,"Python Library Documentation: function kmeans2 in module scipy.cluster.vq

kmeans2(data, k, iter=10, thresh=1e-05, minit='random', missing='warn', check_finite=True)
    Classify a set of observations into k clusters using the k-means algorithm.
    
    The algorithm attempts to minimize the Euclidian distance between
    observations and centroids. Several initialization methods are
    included.
    
    Parameters
    ----------
    data : ndarray
        A 'M' by 'N' array of 'M' observations in 'N' dimensions or a length
        'M' array of 'M' one-dimensional observations.
    k : int or ndarray
        The number of clusters to form as well as the number of
        centroids to generate. If `minit` initialization string is
        'matrix', or if a ndarray is given instead, it is
        interpreted as initial cluster to use instead.
    iter : int, optional
        Number of iterations of the k-means algorithm to run. Note
        that this differs in meaning from the iters parameter to
        the kmeans function.
    thresh : float, optional
        (not used yet)
    minit : str, optional
        Method for initialization. Available methods are 'random',
        'points', and 'matrix':
    
        'random': generate k centroids from a Gaussian with mean and
        variance estimated from the data.
    
        'points': choose k observations (rows) at random from data for
        the initial centroids.
    
        'matrix': interpret the k parameter as a k by M (or length k
        array for one-dimensional data) array of initial centroids.
    missing : str, optional
        Method to deal with empty clusters. Available methods are
        'warn' and 'raise':
    
        'warn': give a warning and continue.
    
        'raise': raise an ClusterError and terminate the algorithm.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default: True
    
    Returns
    -------
    centroid : ndarray
        A 'k' by 'N' array of centroids found at the last iteration of
        k-means.
    label : ndarray
        label[i] is the code or index of the centroid the
        i'th observation is closest to.
",function,"('data', 'k', 'iter', 'thresh', 'minit', 'missing', 'check_finite')","(nan, nan, 10, 1e-05, 'random', 'warn', True)","(nan, nan, 'int', 'float', 'str', 'str', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(data, k, iter=10, thresh=1e-05, minit='random', missing='warn', check_finite=True)"",)"
scipy,1.1.0,scipy.cluster.vq.py_vq,cluster.vq,py_vq,"Python Library Documentation: function py_vq in module scipy.cluster.vq

py_vq(obs, code_book, check_finite=True)
    Python version of vq algorithm.
    
    The algorithm computes the euclidian distance between each
    observation and every frame in the code_book.
    
    Parameters
    ----------
    obs : ndarray
        Expects a rank 2 array. Each row is one observation.
    code_book : ndarray
        Code book to use. Same format than obs. Should have same number of
        features (eg columns) than obs.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default: True
    
    Returns
    -------
    code : ndarray
        code[i] gives the label of the ith obversation, that its code is
        code_book[code[i]].
    mind_dist : ndarray
        min_dist[i] gives the distance between the ith observation and its
        corresponding code.
    
    Notes
    -----
    This function is slower than the C version but works for
    all input types.  If the inputs have the wrong types for the
    C versions of the function, this one is called as a last resort.
    
    It is about 20 times slower than the C version.
",function,"('(obs, code_book, check_finite=True)',)",scipy,1.1.0,scipy.cluster.vq.py_vq,cluster.vq,py_vq,"Python Library Documentation: function py_vq in module scipy.cluster.vq

py_vq(obs, code_book, check_finite=True)
    Python version of vq algorithm.
    
    The algorithm computes the euclidian distance between each
    observation and every frame in the code_book.
    
    Parameters
    ----------
    obs : ndarray
        Expects a rank 2 array. Each row is one observation.
    code_book : ndarray
        Code book to use. Same format than obs. Should have same number of
        features (eg columns) than obs.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default: True
    
    Returns
    -------
    code : ndarray
        code[i] gives the label of the ith obversation, that its code is
        code_book[code[i]].
    mind_dist : ndarray
        min_dist[i] gives the distance between the ith observation and its
        corresponding code.
    
    Notes
    -----
    This function is slower than the C version but works for
    all input types.  If the inputs have the wrong types for the
    C versions of the function, this one is called as a last resort.
    
    It is about 20 times slower than the C version.
",function,"('obs', 'code_book', 'check_finite')","(nan, nan, True)","(nan, nan, 'bool')","('arg_info', 'arg_info', 'arg_info')","('(obs, code_book, check_finite=True)',)"
scipy,1.1.0,scipy.cluster.vq.py_vq2,cluster.vq,py_vq2,"Python Library Documentation: function py_vq2 in module numpy.lib.utils

py_vq2(*args, **kwds)
    `py_vq2` is deprecated, use `py_vq` instead!
    
    Python version of vq algorithm.
    
       The algorithm computes the euclidian distance between each
       observation and every frame in the code_book.
    
       Parameters
       ----------
       obs : ndarray
           Expects a rank 2 array. Each row is one observation.
       code_book : ndarray
           Code book to use. Same format than obs. Should have same number of
           features (eg columns) than obs.
       check_finite : bool, optional
           Whether to check that the input matrices contain only finite numbers.
           Disabling may give a performance gain, but may result in problems
           (crashes, non-termination) if the inputs do contain infinities or NaNs.
           Default: True
    
       Returns
       -------
       code : ndarray
           code[i] gives the label of the ith obversation, that its code is
           code_book[code[i]].
       mind_dist : ndarray
           min_dist[i] gives the distance between the ith observation and its
           corresponding code.
    
       Notes
       -----
       This function is slower than the C version but works for
       all input types.  If the inputs have the wrong types for the
       C versions of the function, this one is called as a last resort.
    
       It is about 20 times slower than the C version.
",function,"('(*args, **kwds)',)",scipy,1.1.0,scipy.cluster.vq.py_vq2,cluster.vq,py_vq2,"Python Library Documentation: function py_vq2 in module numpy.lib.utils

py_vq2(*args, **kwds)
    `py_vq2` is deprecated, use `py_vq` instead!
    
    Python version of vq algorithm.
    
       The algorithm computes the euclidian distance between each
       observation and every frame in the code_book.
    
       Parameters
       ----------
       obs : ndarray
           Expects a rank 2 array. Each row is one observation.
       code_book : ndarray
           Code book to use. Same format than obs. Should have same number of
           features (eg columns) than obs.
       check_finite : bool, optional
           Whether to check that the input matrices contain only finite numbers.
           Disabling may give a performance gain, but may result in problems
           (crashes, non-termination) if the inputs do contain infinities or NaNs.
           Default: True
    
       Returns
       -------
       code : ndarray
           code[i] gives the label of the ith obversation, that its code is
           code_book[code[i]].
       mind_dist : ndarray
           min_dist[i] gives the distance between the ith observation and its
           corresponding code.
    
       Notes
       -----
       This function is slower than the C version but works for
       all input types.  If the inputs have the wrong types for the
       C versions of the function, this one is called as a last resort.
    
       It is about 20 times slower than the C version.
",function,(),(),(),(),"('(*args, **kwds)',)"
scipy,1.1.0,scipy.cluster.vq.vq,cluster.vq,vq,"Python Library Documentation: function vq in module scipy.cluster.vq

vq(obs, code_book, check_finite=True)
    Assign codes from a code book to observations.
    
    Assigns a code from a code book to each observation. Each
    observation vector in the 'M' by 'N' `obs` array is compared with the
    centroids in the code book and assigned the code of the closest
    centroid.
    
    The features in `obs` should have unit variance, which can be
    achieved by passing them through the whiten function.  The code
    book can be created with the k-means algorithm or a different
    encoding algorithm.
    
    Parameters
    ----------
    obs : ndarray
        Each row of the 'M' x 'N' array is an observation.  The columns are
        the ""features"" seen during each observation. The features must be
        whitened first using the whiten function or something equivalent.
    code_book : ndarray
        The code book is usually generated using the k-means algorithm.
        Each row of the array holds a different code, and the columns are
        the features of the code.
    
         >>> #              f0    f1    f2   f3
         >>> code_book = [
         ...             [  1.,   2.,   3.,   4.],  #c0
         ...             [  1.,   2.,   3.,   4.],  #c1
         ...             [  1.,   2.,   3.,   4.]]  #c2
    
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default: True
    
    Returns
    -------
    code : ndarray
        A length M array holding the code book index for each observation.
    dist : ndarray
        The distortion (distance) between the observation and its nearest
        code.
    
    Examples
    --------
    >>> from numpy import array
    >>> from scipy.cluster.vq import vq
    >>> code_book = array([[1.,1.,1.],
    ...                    [2.,2.,2.]])
    >>> features  = array([[  1.9,2.3,1.7],
    ...                    [  1.5,2.5,2.2],
    ...                    [  0.8,0.6,1.7]])
    >>> vq(features,code_book)
    (array([1, 1, 0],'i'), array([ 0.43588989,  0.73484692,  0.83066239]))
",function,"('(obs, code_book, check_finite=True)',)",scipy,1.1.0,scipy.cluster.vq.vq,cluster.vq,vq,"Python Library Documentation: function vq in module scipy.cluster.vq

vq(obs, code_book, check_finite=True)
    Assign codes from a code book to observations.
    
    Assigns a code from a code book to each observation. Each
    observation vector in the 'M' by 'N' `obs` array is compared with the
    centroids in the code book and assigned the code of the closest
    centroid.
    
    The features in `obs` should have unit variance, which can be
    achieved by passing them through the whiten function.  The code
    book can be created with the k-means algorithm or a different
    encoding algorithm.
    
    Parameters
    ----------
    obs : ndarray
        Each row of the 'M' x 'N' array is an observation.  The columns are
        the ""features"" seen during each observation. The features must be
        whitened first using the whiten function or something equivalent.
    code_book : ndarray
        The code book is usually generated using the k-means algorithm.
        Each row of the array holds a different code, and the columns are
        the features of the code.
    
         >>> #              f0    f1    f2   f3
         >>> code_book = [
         ...             [  1.,   2.,   3.,   4.],  #c0
         ...             [  1.,   2.,   3.,   4.],  #c1
         ...             [  1.,   2.,   3.,   4.]]  #c2
    
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default: True
    
    Returns
    -------
    code : ndarray
        A length M array holding the code book index for each observation.
    dist : ndarray
        The distortion (distance) between the observation and its nearest
        code.
    
    Examples
    --------
    >>> from numpy import array
    >>> from scipy.cluster.vq import vq
    >>> code_book = array([[1.,1.,1.],
    ...                    [2.,2.,2.]])
    >>> features  = array([[  1.9,2.3,1.7],
    ...                    [  1.5,2.5,2.2],
    ...                    [  0.8,0.6,1.7]])
    >>> vq(features,code_book)
    (array([1, 1, 0],'i'), array([ 0.43588989,  0.73484692,  0.83066239]))
",function,"('obs', 'code_book', 'check_finite')","(nan, nan, True)","(nan, nan, 'bool')","('arg_info', 'arg_info', 'arg_info')","('(obs, code_book, check_finite=True)',)"
scipy,1.1.0,scipy.cluster.vq.whiten,cluster.vq,whiten,"Python Library Documentation: function whiten in module scipy.cluster.vq

whiten(obs, check_finite=True)
    Normalize a group of observations on a per feature basis.
    
    Before running k-means, it is beneficial to rescale each feature
    dimension of the observation set with whitening. Each feature is
    divided by its standard deviation across all observations to give
    it unit variance.
    
    Parameters
    ----------
    obs : ndarray
        Each row of the array is an observation.  The
        columns are the features seen during each observation.
    
        >>> #         f0    f1    f2
        >>> obs = [[  1.,   1.,   1.],  #o0
        ...        [  2.,   2.,   2.],  #o1
        ...        [  3.,   3.,   3.],  #o2
        ...        [  4.,   4.,   4.]]  #o3
    
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default: True
    
    Returns
    -------
    result : ndarray
        Contains the values in `obs` scaled by the standard deviation
        of each column.
    
    Examples
    --------
    >>> from scipy.cluster.vq import whiten
    >>> features  = np.array([[1.9, 2.3, 1.7],
    ...                       [1.5, 2.5, 2.2],
    ...                       [0.8, 0.6, 1.7,]])
    >>> whiten(features)
    array([[ 4.17944278,  2.69811351,  7.21248917],
           [ 3.29956009,  2.93273208,  9.33380951],
           [ 1.75976538,  0.7038557 ,  7.21248917]])
",function,"('(obs, check_finite=True)',)",scipy,1.1.0,scipy.cluster.vq.whiten,cluster.vq,whiten,"Python Library Documentation: function whiten in module scipy.cluster.vq

whiten(obs, check_finite=True)
    Normalize a group of observations on a per feature basis.
    
    Before running k-means, it is beneficial to rescale each feature
    dimension of the observation set with whitening. Each feature is
    divided by its standard deviation across all observations to give
    it unit variance.
    
    Parameters
    ----------
    obs : ndarray
        Each row of the array is an observation.  The
        columns are the features seen during each observation.
    
        >>> #         f0    f1    f2
        >>> obs = [[  1.,   1.,   1.],  #o0
        ...        [  2.,   2.,   2.],  #o1
        ...        [  3.,   3.,   3.],  #o2
        ...        [  4.,   4.,   4.]]  #o3
    
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default: True
    
    Returns
    -------
    result : ndarray
        Contains the values in `obs` scaled by the standard deviation
        of each column.
    
    Examples
    --------
    >>> from scipy.cluster.vq import whiten
    >>> features  = np.array([[1.9, 2.3, 1.7],
    ...                       [1.5, 2.5, 2.2],
    ...                       [0.8, 0.6, 1.7,]])
    >>> whiten(features)
    array([[ 4.17944278,  2.69811351,  7.21248917],
           [ 3.29956009,  2.93273208,  9.33380951],
           [ 1.75976538,  0.7038557 ,  7.21248917]])
",function,"('obs', 'check_finite')","(nan, True)","(nan, 'bool')","('arg_info', 'arg_info')","('(obs, check_finite=True)',)"
scipy,1.1.0,scipy.cluster.vq.xrange,cluster.vq,range,"Python Library Documentation: class range in module builtins

class range(object)
 |  range(stop) -> range object
 |  range(start, stop[, step]) -> range object
 |  
 |  Return an object that produces a sequence of integers from start (inclusive)
 |  to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.
 |  start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.
 |  These are exactly the valid indices for a list of 4 elements.
 |  When step is given, it specifies the increment (or decrement).
 |  
 |  Methods defined here:
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(...)
 |      Return a reverse iterator.
 |  
 |  count(...)
 |      rangeobject.count(value) -> integer -- return number of occurrences of value
 |  
 |  index(...)
 |      rangeobject.index(value, [start, [stop]]) -> integer -- return index of value.
 |      Raise ValueError if the value is not present.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  start
 |  
 |  step
 |  
 |  stop
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.cluster.vq.xrange,cluster.vq,range,"Python Library Documentation: class range in module builtins

class range(object)
 |  range(stop) -> range object
 |  range(start, stop[, step]) -> range object
 |  
 |  Return an object that produces a sequence of integers from start (inclusive)
 |  to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.
 |  start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.
 |  These are exactly the valid indices for a list of 4 elements.
 |  When step is given, it specifies the increment (or decrement).
 |  
 |  Methods defined here:
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(...)
 |      Return a reverse iterator.
 |  
 |  count(...)
 |      rangeobject.count(value) -> integer -- return number of occurrences of value
 |  
 |  index(...)
 |      rangeobject.index(value, [start, [stop]]) -> integer -- return index of value.
 |      Raise ValueError if the value is not present.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  start
 |  
 |  step
 |  
 |  stop
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.constants.codata.ConstantWarning,constants.codata,ConstantWarning,"Python Library Documentation: class ConstantWarning in module scipy.constants.codata

class ConstantWarning(builtins.DeprecationWarning)
 |  Accessing a constant no longer in current CODATA data set
 |  
 |  Method resolution order:
 |      ConstantWarning
 |      builtins.DeprecationWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.DeprecationWarning:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.constants.codata.ConstantWarning,constants.codata,ConstantWarning,"Python Library Documentation: class ConstantWarning in module scipy.constants.codata

class ConstantWarning(builtins.DeprecationWarning)
 |  Accessing a constant no longer in current CODATA data set
 |  
 |  Method resolution order:
 |      ConstantWarning
 |      builtins.DeprecationWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.DeprecationWarning:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.constants.codata._check_obsolete,constants.codata,_check_obsolete,"Python Library Documentation: function _check_obsolete in module scipy.constants.codata

_check_obsolete(key)
",function,"('(key)',)",scipy,1.1.0,scipy.constants.codata._check_obsolete,constants.codata,_check_obsolete,"Python Library Documentation: function _check_obsolete in module scipy.constants.codata

_check_obsolete(key)
",function,"('key',)","(nan,)","(nan,)","('arg_info',)","('(key)',)"
scipy,1.1.0,scipy.constants.codata.find,constants.codata,find,"Python Library Documentation: function find in module scipy.constants.codata

find(sub=None, disp=False)
    Return list of physical_constant keys containing a given string.
    
    Parameters
    ----------
    sub : str, unicode
        Sub-string to search keys for.  By default, return all keys.
    disp : bool
        If True, print the keys that are found, and return None.
        Otherwise, return the list of keys without printing anything.
    
    Returns
    -------
    keys : list or None
        If `disp` is False, the list of keys is returned.
        Otherwise, None is returned.
    
    See Also
    --------
    codata : Contains the description of `physical_constants`, which, as a
        dictionary literal object, does not itself possess a docstring.
    
    Examples
    --------
    >>> from scipy.constants import find, physical_constants
    
    Which keys in the ``physical_constants`` dictionary contain 'boltzmann'?
    
    >>> find('boltzmann')
    ['Boltzmann constant',
     'Boltzmann constant in Hz/K',
     'Boltzmann constant in eV/K',
     'Boltzmann constant in inverse meters per kelvin',
     'Stefan-Boltzmann constant']
    
    Get the constant called 'Boltzmann constant in Hz/K':
    
    >>> physical_constants['Boltzmann constant in Hz/K']
    (20836612000.0, 'Hz K^-1', 12000.0)
    
    Find constants with 'radius' in the key:
    
    >>> find('radius')
    ['Bohr radius',
     'classical electron radius',
     'deuteron rms charge radius',
     'proton rms charge radius']
    >>> physical_constants['classical electron radius']
    (2.8179403227e-15, 'm', 1.9e-24)
",function,"('(sub=None, disp=False)',)",scipy,1.1.0,scipy.constants.codata.find,constants.codata,find,"Python Library Documentation: function find in module scipy.constants.codata

find(sub=None, disp=False)
    Return list of physical_constant keys containing a given string.
    
    Parameters
    ----------
    sub : str, unicode
        Sub-string to search keys for.  By default, return all keys.
    disp : bool
        If True, print the keys that are found, and return None.
        Otherwise, return the list of keys without printing anything.
    
    Returns
    -------
    keys : list or None
        If `disp` is False, the list of keys is returned.
        Otherwise, None is returned.
    
    See Also
    --------
    codata : Contains the description of `physical_constants`, which, as a
        dictionary literal object, does not itself possess a docstring.
    
    Examples
    --------
    >>> from scipy.constants import find, physical_constants
    
    Which keys in the ``physical_constants`` dictionary contain 'boltzmann'?
    
    >>> find('boltzmann')
    ['Boltzmann constant',
     'Boltzmann constant in Hz/K',
     'Boltzmann constant in eV/K',
     'Boltzmann constant in inverse meters per kelvin',
     'Stefan-Boltzmann constant']
    
    Get the constant called 'Boltzmann constant in Hz/K':
    
    >>> physical_constants['Boltzmann constant in Hz/K']
    (20836612000.0, 'Hz K^-1', 12000.0)
    
    Find constants with 'radius' in the key:
    
    >>> find('radius')
    ['Bohr radius',
     'classical electron radius',
     'deuteron rms charge radius',
     'proton rms charge radius']
    >>> physical_constants['classical electron radius']
    (2.8179403227e-15, 'm', 1.9e-24)
",function,"('sub', 'disp')","(None, False)","('NoneType', 'bool')","('arg_info', 'arg_info')","('(sub=None, disp=False)',)"
scipy,1.1.0,scipy.constants.codata.parse_constants,constants.codata,parse_constants,"Python Library Documentation: function parse_constants in module scipy.constants.codata

parse_constants(d)
",function,"('(d)',)",scipy,1.1.0,scipy.constants.codata.parse_constants,constants.codata,parse_constants,"Python Library Documentation: function parse_constants in module scipy.constants.codata

parse_constants(d)
",function,"('d',)","(nan,)","(nan,)","('arg_info',)","('(d)',)"
scipy,1.1.0,scipy.constants.codata.precision,constants.codata,precision,"Python Library Documentation: function precision in module scipy.constants.codata

precision(key)
    Relative precision in physical_constants indexed by key
    
    Parameters
    ----------
    key : Python string or unicode
        Key in dictionary `physical_constants`
    
    Returns
    -------
    prec : float
        Relative precision in `physical_constants` corresponding to `key`
    
    See Also
    --------
    codata : Contains the description of `physical_constants`, which, as a
        dictionary literal object, does not itself possess a docstring.
    
    Examples
    --------
    >>> from scipy import constants
    >>> constants.precision(u'proton mass')
    1.2555138746605121e-08
",function,"('(key)',)",scipy,1.1.0,scipy.constants.codata.precision,constants.codata,precision,"Python Library Documentation: function precision in module scipy.constants.codata

precision(key)
    Relative precision in physical_constants indexed by key
    
    Parameters
    ----------
    key : Python string or unicode
        Key in dictionary `physical_constants`
    
    Returns
    -------
    prec : float
        Relative precision in `physical_constants` corresponding to `key`
    
    See Also
    --------
    codata : Contains the description of `physical_constants`, which, as a
        dictionary literal object, does not itself possess a docstring.
    
    Examples
    --------
    >>> from scipy import constants
    >>> constants.precision(u'proton mass')
    1.2555138746605121e-08
",function,"('key',)","(nan,)","(nan,)","('arg_info',)","('(key)',)"
scipy,1.1.0,scipy.constants.codata.unit,constants.codata,unit,"Python Library Documentation: function unit in module scipy.constants.codata

unit(key)
    Unit in physical_constants indexed by key
    
    Parameters
    ----------
    key : Python string or unicode
        Key in dictionary `physical_constants`
    
    Returns
    -------
    unit : Python string
        Unit in `physical_constants` corresponding to `key`
    
    See Also
    --------
    codata : Contains the description of `physical_constants`, which, as a
        dictionary literal object, does not itself possess a docstring.
    
    Examples
    --------
    >>> from scipy import constants
    >>> constants.unit(u'proton mass')
    'kg'
",function,"('(key)',)",scipy,1.1.0,scipy.constants.codata.unit,constants.codata,unit,"Python Library Documentation: function unit in module scipy.constants.codata

unit(key)
    Unit in physical_constants indexed by key
    
    Parameters
    ----------
    key : Python string or unicode
        Key in dictionary `physical_constants`
    
    Returns
    -------
    unit : Python string
        Unit in `physical_constants` corresponding to `key`
    
    See Also
    --------
    codata : Contains the description of `physical_constants`, which, as a
        dictionary literal object, does not itself possess a docstring.
    
    Examples
    --------
    >>> from scipy import constants
    >>> constants.unit(u'proton mass')
    'kg'
",function,"('key',)","(nan,)","(nan,)","('arg_info',)","('(key)',)"
scipy,1.1.0,scipy.constants.codata.value,constants.codata,value,"Python Library Documentation: function value in module scipy.constants.codata

value(key)
    Value in physical_constants indexed by key
    
    Parameters
    ----------
    key : Python string or unicode
        Key in dictionary `physical_constants`
    
    Returns
    -------
    value : float
        Value in `physical_constants` corresponding to `key`
    
    See Also
    --------
    codata : Contains the description of `physical_constants`, which, as a
        dictionary literal object, does not itself possess a docstring.
    
    Examples
    --------
    >>> from scipy import constants
    >>> constants.value(u'elementary charge')
        1.6021766208e-19
",function,"('(key)',)",scipy,1.1.0,scipy.constants.codata.value,constants.codata,value,"Python Library Documentation: function value in module scipy.constants.codata

value(key)
    Value in physical_constants indexed by key
    
    Parameters
    ----------
    key : Python string or unicode
        Key in dictionary `physical_constants`
    
    Returns
    -------
    value : float
        Value in `physical_constants` corresponding to `key`
    
    See Also
    --------
    codata : Contains the description of `physical_constants`, which, as a
        dictionary literal object, does not itself possess a docstring.
    
    Examples
    --------
    >>> from scipy import constants
    >>> constants.value(u'elementary charge')
        1.6021766208e-19
",function,"('key',)","(nan,)","(nan,)","('arg_info',)","('(key)',)"
scipy,1.1.0,scipy.constants.constants._cd,constants.constants,value,"Python Library Documentation: function value in module scipy.constants.codata

value(key)
    Value in physical_constants indexed by key
    
    Parameters
    ----------
    key : Python string or unicode
        Key in dictionary `physical_constants`
    
    Returns
    -------
    value : float
        Value in `physical_constants` corresponding to `key`
    
    See Also
    --------
    codata : Contains the description of `physical_constants`, which, as a
        dictionary literal object, does not itself possess a docstring.
    
    Examples
    --------
    >>> from scipy import constants
    >>> constants.value(u'elementary charge')
        1.6021766208e-19
",function,"('(key)',)",scipy,1.1.0,scipy.constants.constants._cd,constants.constants,value,"Python Library Documentation: function value in module scipy.constants.codata

value(key)
    Value in physical_constants indexed by key
    
    Parameters
    ----------
    key : Python string or unicode
        Key in dictionary `physical_constants`
    
    Returns
    -------
    value : float
        Value in `physical_constants` corresponding to `key`
    
    See Also
    --------
    codata : Contains the description of `physical_constants`, which, as a
        dictionary literal object, does not itself possess a docstring.
    
    Examples
    --------
    >>> from scipy import constants
    >>> constants.value(u'elementary charge')
        1.6021766208e-19
",function,"('key',)","(nan,)","(nan,)","('arg_info',)","('(key)',)"
scipy,1.1.0,scipy.constants.constants.convert_temperature,constants.constants,convert_temperature,"Python Library Documentation: function convert_temperature in module scipy.constants.constants

convert_temperature(val, old_scale, new_scale)
    Convert from a temperature scale to another one among Celsius, Kelvin,
    Fahrenheit and Rankine scales.
    
    Parameters
    ----------
    val : array_like
        Value(s) of the temperature(s) to be converted expressed in the
        original scale.
    
    old_scale: str
        Specifies as a string the original scale from which the temperature
        value(s) will be converted. Supported scales are Celsius ('Celsius',
        'celsius', 'C' or 'c'), Kelvin ('Kelvin', 'kelvin', 'K', 'k'),
        Fahrenheit ('Fahrenheit', 'fahrenheit', 'F' or 'f') and Rankine
        ('Rankine', 'rankine', 'R', 'r').
    
    new_scale: str
        Specifies as a string the new scale to which the temperature
        value(s) will be converted. Supported scales are Celsius ('Celsius',
        'celsius', 'C' or 'c'), Kelvin ('Kelvin', 'kelvin', 'K', 'k'),
        Fahrenheit ('Fahrenheit', 'fahrenheit', 'F' or 'f') and Rankine
        ('Rankine', 'rankine', 'R', 'r').
    
    Returns
    -------
    res : float or array of floats
        Value(s) of the converted temperature(s) expressed in the new scale.
    
    Notes
    -----
    .. versionadded:: 0.18.0
    
    Examples
    --------
    >>> from scipy.constants import convert_temperature
    >>> convert_temperature(np.array([-40, 40.0]), 'Celsius', 'Kelvin')
    array([ 233.15,  313.15])
",function,"('(val, old_scale, new_scale)',)",scipy,1.1.0,scipy.constants.constants.convert_temperature,constants.constants,convert_temperature,"Python Library Documentation: function convert_temperature in module scipy.constants.constants

convert_temperature(val, old_scale, new_scale)
    Convert from a temperature scale to another one among Celsius, Kelvin,
    Fahrenheit and Rankine scales.
    
    Parameters
    ----------
    val : array_like
        Value(s) of the temperature(s) to be converted expressed in the
        original scale.
    
    old_scale: str
        Specifies as a string the original scale from which the temperature
        value(s) will be converted. Supported scales are Celsius ('Celsius',
        'celsius', 'C' or 'c'), Kelvin ('Kelvin', 'kelvin', 'K', 'k'),
        Fahrenheit ('Fahrenheit', 'fahrenheit', 'F' or 'f') and Rankine
        ('Rankine', 'rankine', 'R', 'r').
    
    new_scale: str
        Specifies as a string the new scale to which the temperature
        value(s) will be converted. Supported scales are Celsius ('Celsius',
        'celsius', 'C' or 'c'), Kelvin ('Kelvin', 'kelvin', 'K', 'k'),
        Fahrenheit ('Fahrenheit', 'fahrenheit', 'F' or 'f') and Rankine
        ('Rankine', 'rankine', 'R', 'r').
    
    Returns
    -------
    res : float or array of floats
        Value(s) of the converted temperature(s) expressed in the new scale.
    
    Notes
    -----
    .. versionadded:: 0.18.0
    
    Examples
    --------
    >>> from scipy.constants import convert_temperature
    >>> convert_temperature(np.array([-40, 40.0]), 'Celsius', 'Kelvin')
    array([ 233.15,  313.15])
",function,"('val', 'old_scale', 'new_scale')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(val, old_scale, new_scale)',)"
scipy,1.1.0,scipy.constants.constants.lambda2nu,constants.constants,lambda2nu,"Python Library Documentation: function lambda2nu in module scipy.constants.constants

lambda2nu(lambda_)
    Convert wavelength to optical frequency
    
    Parameters
    ----------
    lambda_ : array_like
        Wavelength(s) to be converted.
    
    Returns
    -------
    nu : float or array of floats
        Equivalent optical frequency.
    
    Notes
    -----
    Computes ``nu = c / lambda`` where c = 299792458.0, i.e., the
    (vacuum) speed of light in meters/second.
    
    Examples
    --------
    >>> from scipy.constants import lambda2nu, speed_of_light
    >>> lambda2nu(np.array((1, speed_of_light)))
    array([  2.99792458e+08,   1.00000000e+00])
",function,"('(lambda_)',)",scipy,1.1.0,scipy.constants.constants.lambda2nu,constants.constants,lambda2nu,"Python Library Documentation: function lambda2nu in module scipy.constants.constants

lambda2nu(lambda_)
    Convert wavelength to optical frequency
    
    Parameters
    ----------
    lambda_ : array_like
        Wavelength(s) to be converted.
    
    Returns
    -------
    nu : float or array of floats
        Equivalent optical frequency.
    
    Notes
    -----
    Computes ``nu = c / lambda`` where c = 299792458.0, i.e., the
    (vacuum) speed of light in meters/second.
    
    Examples
    --------
    >>> from scipy.constants import lambda2nu, speed_of_light
    >>> lambda2nu(np.array((1, speed_of_light)))
    array([  2.99792458e+08,   1.00000000e+00])
",function,"('lambda_',)","(nan,)","(nan,)","('arg_info',)","('(lambda_)',)"
scipy,1.1.0,scipy.constants.constants.nu2lambda,constants.constants,nu2lambda,"Python Library Documentation: function nu2lambda in module scipy.constants.constants

nu2lambda(nu)
    Convert optical frequency to wavelength.
    
    Parameters
    ----------
    nu : array_like
        Optical frequency to be converted.
    
    Returns
    -------
    lambda : float or array of floats
        Equivalent wavelength(s).
    
    Notes
    -----
    Computes ``lambda = c / nu`` where c = 299792458.0, i.e., the
    (vacuum) speed of light in meters/second.
    
    Examples
    --------
    >>> from scipy.constants import nu2lambda, speed_of_light
    >>> nu2lambda(np.array((1, speed_of_light)))
    array([  2.99792458e+08,   1.00000000e+00])
",function,"('(nu)',)",scipy,1.1.0,scipy.constants.constants.nu2lambda,constants.constants,nu2lambda,"Python Library Documentation: function nu2lambda in module scipy.constants.constants

nu2lambda(nu)
    Convert optical frequency to wavelength.
    
    Parameters
    ----------
    nu : array_like
        Optical frequency to be converted.
    
    Returns
    -------
    lambda : float or array of floats
        Equivalent wavelength(s).
    
    Notes
    -----
    Computes ``lambda = c / nu`` where c = 299792458.0, i.e., the
    (vacuum) speed of light in meters/second.
    
    Examples
    --------
    >>> from scipy.constants import nu2lambda, speed_of_light
    >>> nu2lambda(np.array((1, speed_of_light)))
    array([  2.99792458e+08,   1.00000000e+00])
",function,"('nu',)","(nan,)","(nan,)","('arg_info',)","('(nu)',)"
scipy,1.1.0,scipy.fftpack.basic._asfarray,fftpack.basic,_asfarray,"Python Library Documentation: function _asfarray in module scipy.fftpack.basic

_asfarray(x)
    Like numpy asfarray, except that it does not modify x dtype if x is
    already an array with a float dtype, and do not cast complex types to
    real.
",function,"('(x)',)",scipy,1.1.0,scipy.fftpack.basic._asfarray,fftpack.basic,_asfarray,"Python Library Documentation: function _asfarray in module scipy.fftpack.basic

_asfarray(x)
    Like numpy asfarray, except that it does not modify x dtype if x is
    already an array with a float dtype, and do not cast complex types to
    real.
",function,"('x',)","(nan,)","(nan,)","('arg_info',)","('(x)',)"
scipy,1.1.0,scipy.fftpack.basic._datacopied,fftpack.basic,_datacopied,"Python Library Documentation: function _datacopied in module scipy.fftpack.basic

_datacopied(arr, original)
    Strict check for `arr` not sharing any data with `original`,
    under the assumption that arr = asarray(original)
",function,"('(arr, original)',)",scipy,1.1.0,scipy.fftpack.basic._datacopied,fftpack.basic,_datacopied,"Python Library Documentation: function _datacopied in module scipy.fftpack.basic

_datacopied(arr, original)
    Strict check for `arr` not sharing any data with `original`,
    under the assumption that arr = asarray(original)
",function,"('arr', 'original')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(arr, original)',)"
scipy,1.1.0,scipy.fftpack.basic._fake_cfft,fftpack.basic,_fake_cfft,"Python Library Documentation: function _fake_cfft in module scipy.fftpack.basic

_fake_cfft(x, n, *a, **kw)
",function,"('(x, n, *a, **kw)',)",scipy,1.1.0,scipy.fftpack.basic._fake_cfft,fftpack.basic,_fake_cfft,"Python Library Documentation: function _fake_cfft in module scipy.fftpack.basic

_fake_cfft(x, n, *a, **kw)
",function,"('x', 'n')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(x, n, *a, **kw)',)"
scipy,1.1.0,scipy.fftpack.basic._fake_cfftnd,fftpack.basic,_fake_cfftnd,"Python Library Documentation: function _fake_cfftnd in module scipy.fftpack.basic

_fake_cfftnd(x, shape, *a, **kw)
",function,"('(x, shape, *a, **kw)',)",scipy,1.1.0,scipy.fftpack.basic._fake_cfftnd,fftpack.basic,_fake_cfftnd,"Python Library Documentation: function _fake_cfftnd in module scipy.fftpack.basic

_fake_cfftnd(x, shape, *a, **kw)
",function,"('x', 'shape')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(x, shape, *a, **kw)',)"
scipy,1.1.0,scipy.fftpack.basic._fake_crfft,fftpack.basic,_fake_crfft,"Python Library Documentation: function _fake_crfft in module scipy.fftpack.basic

_fake_crfft(x, n, *a, **kw)
",function,"('(x, n, *a, **kw)',)",scipy,1.1.0,scipy.fftpack.basic._fake_crfft,fftpack.basic,_fake_crfft,"Python Library Documentation: function _fake_crfft in module scipy.fftpack.basic

_fake_crfft(x, n, *a, **kw)
",function,"('x', 'n')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(x, n, *a, **kw)',)"
scipy,1.1.0,scipy.fftpack.basic._fake_rfft,fftpack.basic,_fake_rfft,"Python Library Documentation: function _fake_rfft in module scipy.fftpack.basic

_fake_rfft(x, n, *a, **kw)
",function,"('(x, n, *a, **kw)',)",scipy,1.1.0,scipy.fftpack.basic._fake_rfft,fftpack.basic,_fake_rfft,"Python Library Documentation: function _fake_rfft in module scipy.fftpack.basic

_fake_rfft(x, n, *a, **kw)
",function,"('x', 'n')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(x, n, *a, **kw)',)"
scipy,1.1.0,scipy.fftpack.basic._fix_shape,fftpack.basic,_fix_shape,"Python Library Documentation: function _fix_shape in module scipy.fftpack.basic

_fix_shape(x, n, axis)
    Internal auxiliary function for _raw_fft, _raw_fftnd.
",function,"('(x, n, axis)',)",scipy,1.1.0,scipy.fftpack.basic._fix_shape,fftpack.basic,_fix_shape,"Python Library Documentation: function _fix_shape in module scipy.fftpack.basic

_fix_shape(x, n, axis)
    Internal auxiliary function for _raw_fft, _raw_fftnd.
",function,"('x', 'n', 'axis')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(x, n, axis)',)"
scipy,1.1.0,scipy.fftpack.basic._is_safe_size,fftpack.basic,_is_safe_size,"Python Library Documentation: function _is_safe_size in module scipy.fftpack.basic

_is_safe_size(n)
    Is the size of FFT such that FFTPACK can handle it in single precision
    with sufficient accuracy?
    
    Composite numbers of 2, 3, and 5 are accepted, as FFTPACK has those
",function,"('(n)',)",scipy,1.1.0,scipy.fftpack.basic._is_safe_size,fftpack.basic,_is_safe_size,"Python Library Documentation: function _is_safe_size in module scipy.fftpack.basic

_is_safe_size(n)
    Is the size of FFT such that FFTPACK can handle it in single precision
    with sufficient accuracy?
    
    Composite numbers of 2, 3, and 5 are accepted, as FFTPACK has those
",function,"('n',)","(nan,)","(nan,)","('arg_info',)","('(n)',)"
scipy,1.1.0,scipy.fftpack.basic._raw_fft,fftpack.basic,_raw_fft,"Python Library Documentation: function _raw_fft in module scipy.fftpack.basic

_raw_fft(x, n, axis, direction, overwrite_x, work_function)
    Internal auxiliary function for fft, ifft, rfft, irfft.
",function,"('(x, n, axis, direction, overwrite_x, work_function)',)",scipy,1.1.0,scipy.fftpack.basic._raw_fft,fftpack.basic,_raw_fft,"Python Library Documentation: function _raw_fft in module scipy.fftpack.basic

_raw_fft(x, n, axis, direction, overwrite_x, work_function)
    Internal auxiliary function for fft, ifft, rfft, irfft.
",function,"('x', 'n', 'axis', 'direction', 'overwrite_x', 'work_function')","(nan, nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, n, axis, direction, overwrite_x, work_function)',)"
scipy,1.1.0,scipy.fftpack.basic._raw_fftn_dispatch,fftpack.basic,_raw_fftn_dispatch,"Python Library Documentation: function _raw_fftn_dispatch in module scipy.fftpack.basic

_raw_fftn_dispatch(x, shape, axes, overwrite_x, direction)
",function,"('(x, shape, axes, overwrite_x, direction)',)",scipy,1.1.0,scipy.fftpack.basic._raw_fftn_dispatch,fftpack.basic,_raw_fftn_dispatch,"Python Library Documentation: function _raw_fftn_dispatch in module scipy.fftpack.basic

_raw_fftn_dispatch(x, shape, axes, overwrite_x, direction)
",function,"('x', 'shape', 'axes', 'overwrite_x', 'direction')","(nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, shape, axes, overwrite_x, direction)',)"
scipy,1.1.0,scipy.fftpack.basic._raw_fftnd,fftpack.basic,_raw_fftnd,"Python Library Documentation: function _raw_fftnd in module scipy.fftpack.basic

_raw_fftnd(x, s, axes, direction, overwrite_x, work_function)
    Internal auxiliary function for fftnd, ifftnd.
",function,"('(x, s, axes, direction, overwrite_x, work_function)',)",scipy,1.1.0,scipy.fftpack.basic._raw_fftnd,fftpack.basic,_raw_fftnd,"Python Library Documentation: function _raw_fftnd in module scipy.fftpack.basic

_raw_fftnd(x, s, axes, direction, overwrite_x, work_function)
    Internal auxiliary function for fftnd, ifftnd.
",function,"('x', 's', 'axes', 'direction', 'overwrite_x', 'work_function')","(nan, nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, s, axes, direction, overwrite_x, work_function)',)"
scipy,1.1.0,scipy.fftpack.basic.fft,fftpack.basic,fft,"Python Library Documentation: function fft in module scipy.fftpack.basic

fft(x, n=None, axis=-1, overwrite_x=False)
    Return discrete Fourier transform of real or complex sequence.
    
    The returned complex array contains ``y(0), y(1),..., y(n-1)`` where
    
    ``y(j) = (x * exp(-2*pi*sqrt(-1)*j*np.arange(n)/n)).sum()``.
    
    Parameters
    ----------
    x : array_like
        Array to Fourier transform.
    n : int, optional
        Length of the Fourier transform.  If ``n < x.shape[axis]``, `x` is
        truncated.  If ``n > x.shape[axis]``, `x` is zero-padded. The
        default results in ``n = x.shape[axis]``.
    axis : int, optional
        Axis along which the fft's are computed; the default is over the
        last axis (i.e., ``axis=-1``).
    overwrite_x : bool, optional
        If True, the contents of `x` can be destroyed; the default is False.
    
    Returns
    -------
    z : complex ndarray
        with the elements::
    
            [y(0),y(1),..,y(n/2),y(1-n/2),...,y(-1)]        if n is even
            [y(0),y(1),..,y((n-1)/2),y(-(n-1)/2),...,y(-1)]  if n is odd
    
        where::
    
            y(j) = sum[k=0..n-1] x[k] * exp(-sqrt(-1)*j*k* 2*pi/n), j = 0..n-1
    
    See Also
    --------
    ifft : Inverse FFT
    rfft : FFT of a real sequence
    
    Notes
    -----
    The packing of the result is ""standard"": If ``A = fft(a, n)``, then
    ``A[0]`` contains the zero-frequency term, ``A[1:n/2]`` contains the
    positive-frequency terms, and ``A[n/2:]`` contains the negative-frequency
    terms, in order of decreasingly negative frequency. So for an 8-point
    transform, the frequencies of the result are [0, 1, 2, 3, -4, -3, -2, -1].
    To rearrange the fft output so that the zero-frequency component is
    centered, like [-4, -3, -2, -1,  0,  1,  2,  3], use `fftshift`.
    
    Both single and double precision routines are implemented.  Half precision
    inputs will be converted to single precision.  Non floating-point inputs
    will be converted to double precision.  Long-double precision inputs are
    not supported.
    
    This function is most efficient when `n` is a power of two, and least
    efficient when `n` is prime.
    
    Note that if ``x`` is real-valued then ``A[j] == A[n-j].conjugate()``.
    If ``x`` is real-valued and ``n`` is even then ``A[n/2]`` is real.
    
    If the data type of `x` is real, a ""real FFT"" algorithm is automatically
    used, which roughly halves the computation time.  To increase efficiency
    a little further, use `rfft`, which does the same calculation, but only
    outputs half of the symmetrical spectrum.  If the data is both real and
    symmetrical, the `dct` can again double the efficiency, by generating
    half of the spectrum from half of the signal.
    
    Examples
    --------
    >>> from scipy.fftpack import fft, ifft
    >>> x = np.arange(5)
    >>> np.allclose(fft(ifft(x)), x, atol=1e-15)  # within numerical accuracy.
    True
",function,"('(x, n=None, axis=-1, overwrite_x=False)',)",scipy,1.1.0,scipy.fftpack.basic.fft,fftpack.basic,fft,"Python Library Documentation: function fft in module scipy.fftpack.basic

fft(x, n=None, axis=-1, overwrite_x=False)
    Return discrete Fourier transform of real or complex sequence.
    
    The returned complex array contains ``y(0), y(1),..., y(n-1)`` where
    
    ``y(j) = (x * exp(-2*pi*sqrt(-1)*j*np.arange(n)/n)).sum()``.
    
    Parameters
    ----------
    x : array_like
        Array to Fourier transform.
    n : int, optional
        Length of the Fourier transform.  If ``n < x.shape[axis]``, `x` is
        truncated.  If ``n > x.shape[axis]``, `x` is zero-padded. The
        default results in ``n = x.shape[axis]``.
    axis : int, optional
        Axis along which the fft's are computed; the default is over the
        last axis (i.e., ``axis=-1``).
    overwrite_x : bool, optional
        If True, the contents of `x` can be destroyed; the default is False.
    
    Returns
    -------
    z : complex ndarray
        with the elements::
    
            [y(0),y(1),..,y(n/2),y(1-n/2),...,y(-1)]        if n is even
            [y(0),y(1),..,y((n-1)/2),y(-(n-1)/2),...,y(-1)]  if n is odd
    
        where::
    
            y(j) = sum[k=0..n-1] x[k] * exp(-sqrt(-1)*j*k* 2*pi/n), j = 0..n-1
    
    See Also
    --------
    ifft : Inverse FFT
    rfft : FFT of a real sequence
    
    Notes
    -----
    The packing of the result is ""standard"": If ``A = fft(a, n)``, then
    ``A[0]`` contains the zero-frequency term, ``A[1:n/2]`` contains the
    positive-frequency terms, and ``A[n/2:]`` contains the negative-frequency
    terms, in order of decreasingly negative frequency. So for an 8-point
    transform, the frequencies of the result are [0, 1, 2, 3, -4, -3, -2, -1].
    To rearrange the fft output so that the zero-frequency component is
    centered, like [-4, -3, -2, -1,  0,  1,  2,  3], use `fftshift`.
    
    Both single and double precision routines are implemented.  Half precision
    inputs will be converted to single precision.  Non floating-point inputs
    will be converted to double precision.  Long-double precision inputs are
    not supported.
    
    This function is most efficient when `n` is a power of two, and least
    efficient when `n` is prime.
    
    Note that if ``x`` is real-valued then ``A[j] == A[n-j].conjugate()``.
    If ``x`` is real-valued and ``n`` is even then ``A[n/2]`` is real.
    
    If the data type of `x` is real, a ""real FFT"" algorithm is automatically
    used, which roughly halves the computation time.  To increase efficiency
    a little further, use `rfft`, which does the same calculation, but only
    outputs half of the symmetrical spectrum.  If the data is both real and
    symmetrical, the `dct` can again double the efficiency, by generating
    half of the spectrum from half of the signal.
    
    Examples
    --------
    >>> from scipy.fftpack import fft, ifft
    >>> x = np.arange(5)
    >>> np.allclose(fft(ifft(x)), x, atol=1e-15)  # within numerical accuracy.
    True
",function,"('x', 'n', 'axis', 'overwrite_x')","(nan, None, -1, False)","(nan, 'NoneType', 'int', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, n=None, axis=-1, overwrite_x=False)',)"
scipy,1.1.0,scipy.fftpack.basic.fft2,fftpack.basic,fft2,"Python Library Documentation: function fft2 in module scipy.fftpack.basic

fft2(x, shape=None, axes=(-2, -1), overwrite_x=False)
    2-D discrete Fourier transform.
    
    Return the two-dimensional discrete Fourier transform of the 2-D argument
    `x`.
    
    See Also
    --------
    fftn : for detailed information.
",function,"('(x, shape=None, axes=(-2, -1), overwrite_x=False)',)",scipy,1.1.0,scipy.fftpack.basic.fft2,fftpack.basic,fft2,"Python Library Documentation: function fft2 in module scipy.fftpack.basic

fft2(x, shape=None, axes=(-2, -1), overwrite_x=False)
    2-D discrete Fourier transform.
    
    Return the two-dimensional discrete Fourier transform of the 2-D argument
    `x`.
    
    See Also
    --------
    fftn : for detailed information.
",function,"('x', 'shape', 'axes', 'overwrite_x')","(nan, None, (-2, -1), False)","(nan, 'NoneType', 'tuple', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, shape=None, axes=(-2, -1), overwrite_x=False)',)"
scipy,1.1.0,scipy.fftpack.basic.fftn,fftpack.basic,fftn,"Python Library Documentation: function fftn in module scipy.fftpack.basic

fftn(x, shape=None, axes=None, overwrite_x=False)
    Return multidimensional discrete Fourier transform.
    
    The returned array contains::
    
      y[j_1,..,j_d] = sum[k_1=0..n_1-1, ..., k_d=0..n_d-1]
         x[k_1,..,k_d] * prod[i=1..d] exp(-sqrt(-1)*2*pi/n_i * j_i * k_i)
    
    where d = len(x.shape) and n = x.shape.
    
    Parameters
    ----------
    x : array_like
        The (n-dimensional) array to transform.
    shape : tuple of ints, optional
        The shape of the result.  If both `shape` and `axes` (see below) are
        None, `shape` is ``x.shape``; if `shape` is None but `axes` is
        not None, then `shape` is ``scipy.take(x.shape, axes, axis=0)``.
        If ``shape[i] > x.shape[i]``, the i-th dimension is padded with zeros.
        If ``shape[i] < x.shape[i]``, the i-th dimension is truncated to
        length ``shape[i]``.
    axes : array_like of ints, optional
        The axes of `x` (`y` if `shape` is not None) along which the
        transform is applied.
    overwrite_x : bool, optional
        If True, the contents of `x` can be destroyed.  Default is False.
    
    Returns
    -------
    y : complex-valued n-dimensional numpy array
        The (n-dimensional) DFT of the input array.
    
    See Also
    --------
    ifftn
    
    Notes
    -----
    If ``x`` is real-valued, then
    ``y[..., j_i, ...] == y[..., n_i-j_i, ...].conjugate()``.
    
    Both single and double precision routines are implemented.  Half precision
    inputs will be converted to single precision.  Non floating-point inputs
    will be converted to double precision.  Long-double precision inputs are
    not supported.
    
    Examples
    --------
    >>> from scipy.fftpack import fftn, ifftn
    >>> y = (-np.arange(16), 8 - np.arange(16), np.arange(16))
    >>> np.allclose(y, fftn(ifftn(y)))
    True
",function,"('(x, shape=None, axes=None, overwrite_x=False)',)",scipy,1.1.0,scipy.fftpack.basic.fftn,fftpack.basic,fftn,"Python Library Documentation: function fftn in module scipy.fftpack.basic

fftn(x, shape=None, axes=None, overwrite_x=False)
    Return multidimensional discrete Fourier transform.
    
    The returned array contains::
    
      y[j_1,..,j_d] = sum[k_1=0..n_1-1, ..., k_d=0..n_d-1]
         x[k_1,..,k_d] * prod[i=1..d] exp(-sqrt(-1)*2*pi/n_i * j_i * k_i)
    
    where d = len(x.shape) and n = x.shape.
    
    Parameters
    ----------
    x : array_like
        The (n-dimensional) array to transform.
    shape : tuple of ints, optional
        The shape of the result.  If both `shape` and `axes` (see below) are
        None, `shape` is ``x.shape``; if `shape` is None but `axes` is
        not None, then `shape` is ``scipy.take(x.shape, axes, axis=0)``.
        If ``shape[i] > x.shape[i]``, the i-th dimension is padded with zeros.
        If ``shape[i] < x.shape[i]``, the i-th dimension is truncated to
        length ``shape[i]``.
    axes : array_like of ints, optional
        The axes of `x` (`y` if `shape` is not None) along which the
        transform is applied.
    overwrite_x : bool, optional
        If True, the contents of `x` can be destroyed.  Default is False.
    
    Returns
    -------
    y : complex-valued n-dimensional numpy array
        The (n-dimensional) DFT of the input array.
    
    See Also
    --------
    ifftn
    
    Notes
    -----
    If ``x`` is real-valued, then
    ``y[..., j_i, ...] == y[..., n_i-j_i, ...].conjugate()``.
    
    Both single and double precision routines are implemented.  Half precision
    inputs will be converted to single precision.  Non floating-point inputs
    will be converted to double precision.  Long-double precision inputs are
    not supported.
    
    Examples
    --------
    >>> from scipy.fftpack import fftn, ifftn
    >>> y = (-np.arange(16), 8 - np.arange(16), np.arange(16))
    >>> np.allclose(y, fftn(ifftn(y)))
    True
",function,"('x', 'shape', 'axes', 'overwrite_x')","(nan, None, None, False)","(nan, 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, shape=None, axes=None, overwrite_x=False)',)"
scipy,1.1.0,scipy.fftpack.basic.ifft,fftpack.basic,ifft,"Python Library Documentation: function ifft in module scipy.fftpack.basic

ifft(x, n=None, axis=-1, overwrite_x=False)
    Return discrete inverse Fourier transform of real or complex sequence.
    
    The returned complex array contains ``y(0), y(1),..., y(n-1)`` where
    
    ``y(j) = (x * exp(2*pi*sqrt(-1)*j*np.arange(n)/n)).mean()``.
    
    Parameters
    ----------
    x : array_like
        Transformed data to invert.
    n : int, optional
        Length of the inverse Fourier transform.  If ``n < x.shape[axis]``,
        `x` is truncated.  If ``n > x.shape[axis]``, `x` is zero-padded.
        The default results in ``n = x.shape[axis]``.
    axis : int, optional
        Axis along which the ifft's are computed; the default is over the
        last axis (i.e., ``axis=-1``).
    overwrite_x : bool, optional
        If True, the contents of `x` can be destroyed; the default is False.
    
    Returns
    -------
    ifft : ndarray of floats
        The inverse discrete Fourier transform.
    
    See Also
    --------
    fft : Forward FFT
    
    Notes
    -----
    Both single and double precision routines are implemented.  Half precision
    inputs will be converted to single precision.  Non floating-point inputs
    will be converted to double precision.  Long-double precision inputs are
    not supported.
    
    This function is most efficient when `n` is a power of two, and least
    efficient when `n` is prime.
    
    If the data type of `x` is real, a ""real IFFT"" algorithm is automatically
    used, which roughly halves the computation time.
    
    Examples
    --------
    >>> from scipy.fftpack import fft, ifft
    >>> import numpy as np
    >>> x = np.arange(5)
    >>> np.allclose(ifft(fft(x)), x, atol=1e-15)  # within numerical accuracy.
    True
",function,"('(x, n=None, axis=-1, overwrite_x=False)',)",scipy,1.1.0,scipy.fftpack.basic.ifft,fftpack.basic,ifft,"Python Library Documentation: function ifft in module scipy.fftpack.basic

ifft(x, n=None, axis=-1, overwrite_x=False)
    Return discrete inverse Fourier transform of real or complex sequence.
    
    The returned complex array contains ``y(0), y(1),..., y(n-1)`` where
    
    ``y(j) = (x * exp(2*pi*sqrt(-1)*j*np.arange(n)/n)).mean()``.
    
    Parameters
    ----------
    x : array_like
        Transformed data to invert.
    n : int, optional
        Length of the inverse Fourier transform.  If ``n < x.shape[axis]``,
        `x` is truncated.  If ``n > x.shape[axis]``, `x` is zero-padded.
        The default results in ``n = x.shape[axis]``.
    axis : int, optional
        Axis along which the ifft's are computed; the default is over the
        last axis (i.e., ``axis=-1``).
    overwrite_x : bool, optional
        If True, the contents of `x` can be destroyed; the default is False.
    
    Returns
    -------
    ifft : ndarray of floats
        The inverse discrete Fourier transform.
    
    See Also
    --------
    fft : Forward FFT
    
    Notes
    -----
    Both single and double precision routines are implemented.  Half precision
    inputs will be converted to single precision.  Non floating-point inputs
    will be converted to double precision.  Long-double precision inputs are
    not supported.
    
    This function is most efficient when `n` is a power of two, and least
    efficient when `n` is prime.
    
    If the data type of `x` is real, a ""real IFFT"" algorithm is automatically
    used, which roughly halves the computation time.
    
    Examples
    --------
    >>> from scipy.fftpack import fft, ifft
    >>> import numpy as np
    >>> x = np.arange(5)
    >>> np.allclose(ifft(fft(x)), x, atol=1e-15)  # within numerical accuracy.
    True
",function,"('x', 'n', 'axis', 'overwrite_x')","(nan, None, -1, False)","(nan, 'NoneType', 'int', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, n=None, axis=-1, overwrite_x=False)',)"
scipy,1.1.0,scipy.fftpack.basic.ifft2,fftpack.basic,ifft2,"Python Library Documentation: function ifft2 in module scipy.fftpack.basic

ifft2(x, shape=None, axes=(-2, -1), overwrite_x=False)
    2-D discrete inverse Fourier transform of real or complex sequence.
    
    Return inverse two-dimensional discrete Fourier transform of
    arbitrary type sequence x.
    
    See `ifft` for more information.
    
    See also
    --------
    fft2, ifft
",function,"('(x, shape=None, axes=(-2, -1), overwrite_x=False)',)",scipy,1.1.0,scipy.fftpack.basic.ifft2,fftpack.basic,ifft2,"Python Library Documentation: function ifft2 in module scipy.fftpack.basic

ifft2(x, shape=None, axes=(-2, -1), overwrite_x=False)
    2-D discrete inverse Fourier transform of real or complex sequence.
    
    Return inverse two-dimensional discrete Fourier transform of
    arbitrary type sequence x.
    
    See `ifft` for more information.
    
    See also
    --------
    fft2, ifft
",function,"('x', 'shape', 'axes', 'overwrite_x')","(nan, None, (-2, -1), False)","(nan, 'NoneType', 'tuple', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, shape=None, axes=(-2, -1), overwrite_x=False)',)"
scipy,1.1.0,scipy.fftpack.basic.ifftn,fftpack.basic,ifftn,"Python Library Documentation: function ifftn in module scipy.fftpack.basic

ifftn(x, shape=None, axes=None, overwrite_x=False)
    Return inverse multi-dimensional discrete Fourier transform of
    arbitrary type sequence x.
    
    The returned array contains::
    
      y[j_1,..,j_d] = 1/p * sum[k_1=0..n_1-1, ..., k_d=0..n_d-1]
         x[k_1,..,k_d] * prod[i=1..d] exp(sqrt(-1)*2*pi/n_i * j_i * k_i)
    
    where ``d = len(x.shape)``, ``n = x.shape``, and ``p = prod[i=1..d] n_i``.
    
    For description of parameters see `fftn`.
    
    See Also
    --------
    fftn : for detailed information.
    
    Examples
    --------
    >>> from scipy.fftpack import fftn, ifftn
    >>> import numpy as np
    >>> y = (-np.arange(16), 8 - np.arange(16), np.arange(16))
    >>> np.allclose(y, ifftn(fftn(y)))
    True
",function,"('(x, shape=None, axes=None, overwrite_x=False)',)",scipy,1.1.0,scipy.fftpack.basic.ifftn,fftpack.basic,ifftn,"Python Library Documentation: function ifftn in module scipy.fftpack.basic

ifftn(x, shape=None, axes=None, overwrite_x=False)
    Return inverse multi-dimensional discrete Fourier transform of
    arbitrary type sequence x.
    
    The returned array contains::
    
      y[j_1,..,j_d] = 1/p * sum[k_1=0..n_1-1, ..., k_d=0..n_d-1]
         x[k_1,..,k_d] * prod[i=1..d] exp(sqrt(-1)*2*pi/n_i * j_i * k_i)
    
    where ``d = len(x.shape)``, ``n = x.shape``, and ``p = prod[i=1..d] n_i``.
    
    For description of parameters see `fftn`.
    
    See Also
    --------
    fftn : for detailed information.
    
    Examples
    --------
    >>> from scipy.fftpack import fftn, ifftn
    >>> import numpy as np
    >>> y = (-np.arange(16), 8 - np.arange(16), np.arange(16))
    >>> np.allclose(y, ifftn(fftn(y)))
    True
",function,"('x', 'shape', 'axes', 'overwrite_x')","(nan, None, None, False)","(nan, 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, shape=None, axes=None, overwrite_x=False)',)"
scipy,1.1.0,scipy.fftpack.basic.irfft,fftpack.basic,irfft,"Python Library Documentation: function irfft in module scipy.fftpack.basic

irfft(x, n=None, axis=-1, overwrite_x=False)
    Return inverse discrete Fourier transform of real sequence x.
    
    The contents of `x` are interpreted as the output of the `rfft`
    function.
    
    Parameters
    ----------
    x : array_like
        Transformed data to invert.
    n : int, optional
        Length of the inverse Fourier transform.
        If n < x.shape[axis], x is truncated.
        If n > x.shape[axis], x is zero-padded.
        The default results in n = x.shape[axis].
    axis : int, optional
        Axis along which the ifft's are computed; the default is over
        the last axis (i.e., axis=-1).
    overwrite_x : bool, optional
        If True, the contents of `x` can be destroyed; the default is False.
    
    Returns
    -------
    irfft : ndarray of floats
        The inverse discrete Fourier transform.
    
    See Also
    --------
    rfft, ifft, numpy.fft.irfft
    
    Notes
    -----
    The returned real array contains::
    
        [y(0),y(1),...,y(n-1)]
    
    where for n is even::
    
        y(j) = 1/n (sum[k=1..n/2-1] (x[2*k-1]+sqrt(-1)*x[2*k])
                                     * exp(sqrt(-1)*j*k* 2*pi/n)
                    + c.c. + x[0] + (-1)**(j) x[n-1])
    
    and for n is odd::
    
        y(j) = 1/n (sum[k=1..(n-1)/2] (x[2*k-1]+sqrt(-1)*x[2*k])
                                     * exp(sqrt(-1)*j*k* 2*pi/n)
                    + c.c. + x[0])
    
    c.c. denotes complex conjugate of preceding expression.
    
    For details on input parameters, see `rfft`.
    
    To process (conjugate-symmetric) frequency-domain data with a complex
    datatype, consider using the related function `numpy.fft.irfft`.
",function,"('(x, n=None, axis=-1, overwrite_x=False)',)",scipy,1.1.0,scipy.fftpack.basic.irfft,fftpack.basic,irfft,"Python Library Documentation: function irfft in module scipy.fftpack.basic

irfft(x, n=None, axis=-1, overwrite_x=False)
    Return inverse discrete Fourier transform of real sequence x.
    
    The contents of `x` are interpreted as the output of the `rfft`
    function.
    
    Parameters
    ----------
    x : array_like
        Transformed data to invert.
    n : int, optional
        Length of the inverse Fourier transform.
        If n < x.shape[axis], x is truncated.
        If n > x.shape[axis], x is zero-padded.
        The default results in n = x.shape[axis].
    axis : int, optional
        Axis along which the ifft's are computed; the default is over
        the last axis (i.e., axis=-1).
    overwrite_x : bool, optional
        If True, the contents of `x` can be destroyed; the default is False.
    
    Returns
    -------
    irfft : ndarray of floats
        The inverse discrete Fourier transform.
    
    See Also
    --------
    rfft, ifft, numpy.fft.irfft
    
    Notes
    -----
    The returned real array contains::
    
        [y(0),y(1),...,y(n-1)]
    
    where for n is even::
    
        y(j) = 1/n (sum[k=1..n/2-1] (x[2*k-1]+sqrt(-1)*x[2*k])
                                     * exp(sqrt(-1)*j*k* 2*pi/n)
                    + c.c. + x[0] + (-1)**(j) x[n-1])
    
    and for n is odd::
    
        y(j) = 1/n (sum[k=1..(n-1)/2] (x[2*k-1]+sqrt(-1)*x[2*k])
                                     * exp(sqrt(-1)*j*k* 2*pi/n)
                    + c.c. + x[0])
    
    c.c. denotes complex conjugate of preceding expression.
    
    For details on input parameters, see `rfft`.
    
    To process (conjugate-symmetric) frequency-domain data with a complex
    datatype, consider using the related function `numpy.fft.irfft`.
",function,"('x', 'n', 'axis', 'overwrite_x')","(nan, None, -1, False)","(nan, 'NoneType', 'int', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, n=None, axis=-1, overwrite_x=False)',)"
scipy,1.1.0,scipy.fftpack.basic.istype,fftpack.basic,istype,"Python Library Documentation: function istype in module scipy.fftpack.basic

istype(arr, typeclass)
",function,"('(arr, typeclass)',)",scipy,1.1.0,scipy.fftpack.basic.istype,fftpack.basic,istype,"Python Library Documentation: function istype in module scipy.fftpack.basic

istype(arr, typeclass)
",function,"('arr', 'typeclass')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(arr, typeclass)',)"
scipy,1.1.0,scipy.fftpack.basic.rfft,fftpack.basic,rfft,"Python Library Documentation: function rfft in module scipy.fftpack.basic

rfft(x, n=None, axis=-1, overwrite_x=False)
    Discrete Fourier transform of a real sequence.
    
    Parameters
    ----------
    x : array_like, real-valued
        The data to transform.
    n : int, optional
        Defines the length of the Fourier transform.  If `n` is not specified
        (the default) then ``n = x.shape[axis]``.  If ``n < x.shape[axis]``,
        `x` is truncated, if ``n > x.shape[axis]``, `x` is zero-padded.
    axis : int, optional
        The axis along which the transform is applied.  The default is the
        last axis.
    overwrite_x : bool, optional
        If set to true, the contents of `x` can be overwritten. Default is
        False.
    
    Returns
    -------
    z : real ndarray
        The returned real array contains::
    
          [y(0),Re(y(1)),Im(y(1)),...,Re(y(n/2))]              if n is even
          [y(0),Re(y(1)),Im(y(1)),...,Re(y(n/2)),Im(y(n/2))]   if n is odd
    
        where::
    
          y(j) = sum[k=0..n-1] x[k] * exp(-sqrt(-1)*j*k*2*pi/n)
          j = 0..n-1
    
    See Also
    --------
    fft, irfft, numpy.fft.rfft
    
    Notes
    -----
    Within numerical accuracy, ``y == rfft(irfft(y))``.
    
    Both single and double precision routines are implemented.  Half precision
    inputs will be converted to single precision.  Non floating-point inputs
    will be converted to double precision.  Long-double precision inputs are
    not supported.
    
    To get an output with a complex datatype, consider using the related
    function `numpy.fft.rfft`.
    
    Examples
    --------
    >>> from scipy.fftpack import fft, rfft
    >>> a = [9, -9, 1, 3]
    >>> fft(a)
    array([  4. +0.j,   8.+12.j,  16. +0.j,   8.-12.j])
    >>> rfft(a)
    array([  4.,   8.,  12.,  16.])
",function,"('(x, n=None, axis=-1, overwrite_x=False)',)",scipy,1.1.0,scipy.fftpack.basic.rfft,fftpack.basic,rfft,"Python Library Documentation: function rfft in module scipy.fftpack.basic

rfft(x, n=None, axis=-1, overwrite_x=False)
    Discrete Fourier transform of a real sequence.
    
    Parameters
    ----------
    x : array_like, real-valued
        The data to transform.
    n : int, optional
        Defines the length of the Fourier transform.  If `n` is not specified
        (the default) then ``n = x.shape[axis]``.  If ``n < x.shape[axis]``,
        `x` is truncated, if ``n > x.shape[axis]``, `x` is zero-padded.
    axis : int, optional
        The axis along which the transform is applied.  The default is the
        last axis.
    overwrite_x : bool, optional
        If set to true, the contents of `x` can be overwritten. Default is
        False.
    
    Returns
    -------
    z : real ndarray
        The returned real array contains::
    
          [y(0),Re(y(1)),Im(y(1)),...,Re(y(n/2))]              if n is even
          [y(0),Re(y(1)),Im(y(1)),...,Re(y(n/2)),Im(y(n/2))]   if n is odd
    
        where::
    
          y(j) = sum[k=0..n-1] x[k] * exp(-sqrt(-1)*j*k*2*pi/n)
          j = 0..n-1
    
    See Also
    --------
    fft, irfft, numpy.fft.rfft
    
    Notes
    -----
    Within numerical accuracy, ``y == rfft(irfft(y))``.
    
    Both single and double precision routines are implemented.  Half precision
    inputs will be converted to single precision.  Non floating-point inputs
    will be converted to double precision.  Long-double precision inputs are
    not supported.
    
    To get an output with a complex datatype, consider using the related
    function `numpy.fft.rfft`.
    
    Examples
    --------
    >>> from scipy.fftpack import fft, rfft
    >>> a = [9, -9, 1, 3]
    >>> fft(a)
    array([  4. +0.j,   8.+12.j,  16. +0.j,   8.-12.j])
    >>> rfft(a)
    array([  4.,   8.,  12.,  16.])
",function,"('x', 'n', 'axis', 'overwrite_x')","(nan, None, -1, False)","(nan, 'NoneType', 'int', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, n=None, axis=-1, overwrite_x=False)',)"
scipy,1.1.0,scipy.fftpack.basic.swapaxes,fftpack.basic,swapaxes,"Python Library Documentation: function swapaxes in module numpy.core.fromnumeric

swapaxes(a, axis1, axis2)
    Interchange two axes of an array.
    
    Parameters
    ----------
    a : array_like
        Input array.
    axis1 : int
        First axis.
    axis2 : int
        Second axis.
    
    Returns
    -------
    a_swapped : ndarray
        For NumPy >= 1.10.0, if `a` is an ndarray, then a view of `a` is
        returned; otherwise a new array is created. For earlier NumPy
        versions a view of `a` is returned only if the order of the
        axes is changed, otherwise the input array is returned.
    
    Examples
    --------
    >>> x = np.array([[1,2,3]])
    >>> np.swapaxes(x,0,1)
    array([[1],
           [2],
           [3]])
    
    >>> x = np.array([[[0,1],[2,3]],[[4,5],[6,7]]])
    >>> x
    array([[[0, 1],
            [2, 3]],
           [[4, 5],
            [6, 7]]])
    
    >>> np.swapaxes(x,0,2)
    array([[[0, 4],
            [2, 6]],
           [[1, 5],
            [3, 7]]])
",function,"('(a, axis1, axis2)',)",scipy,1.1.0,scipy.fftpack.basic.swapaxes,fftpack.basic,swapaxes,"Python Library Documentation: function swapaxes in module numpy.core.fromnumeric

swapaxes(a, axis1, axis2)
    Interchange two axes of an array.
    
    Parameters
    ----------
    a : array_like
        Input array.
    axis1 : int
        First axis.
    axis2 : int
        Second axis.
    
    Returns
    -------
    a_swapped : ndarray
        For NumPy >= 1.10.0, if `a` is an ndarray, then a view of `a` is
        returned; otherwise a new array is created. For earlier NumPy
        versions a view of `a` is returned only if the order of the
        axes is changed, otherwise the input array is returned.
    
    Examples
    --------
    >>> x = np.array([[1,2,3]])
    >>> np.swapaxes(x,0,1)
    array([[1],
           [2],
           [3]])
    
    >>> x = np.array([[[0,1],[2,3]],[[4,5],[6,7]]])
    >>> x
    array([[[0, 1],
            [2, 3]],
           [[4, 5],
            [6, 7]]])
    
    >>> np.swapaxes(x,0,2)
    array([[[0, 4],
            [2, 6]],
           [[1, 5],
            [3, 7]]])
",function,"('a', 'axis1', 'axis2')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(a, axis1, axis2)',)"
scipy,1.1.0,scipy.fftpack.helper.fftfreq,fftpack.helper,fftfreq,"Python Library Documentation: function fftfreq in module numpy.fft.helper

fftfreq(n, d=1.0)
    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
    ----------
    n : int
        Window length.
    d : scalar, optional
        Sample spacing (inverse of the sampling rate). Defaults to 1.
    
    Returns
    -------
    f : ndarray
        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, -5.  , -3.75, -2.5 , -1.25])
",function,"('(n, d=1.0)',)",scipy,1.1.0,scipy.fftpack.helper.fftfreq,fftpack.helper,fftfreq,"Python Library Documentation: function fftfreq in module numpy.fft.helper

fftfreq(n, d=1.0)
    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
    ----------
    n : int
        Window length.
    d : scalar, optional
        Sample spacing (inverse of the sampling rate). Defaults to 1.
    
    Returns
    -------
    f : ndarray
        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, -5.  , -3.75, -2.5 , -1.25])
",function,"('n', 'd')","(nan, 1.0)","(nan, 'float')","('arg_info', 'arg_info')","('(n, d=1.0)',)"
scipy,1.1.0,scipy.fftpack.helper.fftshift,fftpack.helper,fftshift,"Python Library Documentation: function fftshift in module numpy.fft.helper

fftshift(x, axes=None)
    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
    ----------
    x : array_like
        Input array.
    axes : int or shape tuple, optional
        Axes over which to shift.  Default is None, which shifts all axes.
    
    Returns
    -------
    y : ndarray
        The shifted array.
    
    See Also
    --------
    ifftshift : The inverse of `fftshift`.
    
    Examples
    --------
    >>> freqs = np.fft.fftfreq(10, 0.1)
    >>> freqs
    array([ 0.,  1.,  2.,  3.,  4., -5., -4., -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.]])
",function,"('(x, axes=None)',)",scipy,1.1.0,scipy.fftpack.helper.fftshift,fftpack.helper,fftshift,"Python Library Documentation: function fftshift in module numpy.fft.helper

fftshift(x, axes=None)
    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
    ----------
    x : array_like
        Input array.
    axes : int or shape tuple, optional
        Axes over which to shift.  Default is None, which shifts all axes.
    
    Returns
    -------
    y : ndarray
        The shifted array.
    
    See Also
    --------
    ifftshift : The inverse of `fftshift`.
    
    Examples
    --------
    >>> freqs = np.fft.fftfreq(10, 0.1)
    >>> freqs
    array([ 0.,  1.,  2.,  3.,  4., -5., -4., -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.]])
",function,"('x', 'axes')","(nan, None)","(nan, 'NoneType')","('arg_info', 'arg_info')","('(x, axes=None)',)"
scipy,1.1.0,scipy.fftpack.helper.ifftshift,fftpack.helper,ifftshift,"Python Library Documentation: function ifftshift in module numpy.fft.helper

ifftshift(x, axes=None)
    The inverse of `fftshift`. Although identical for even-length `x`, the
    functions differ by one sample for odd-length `x`.
    
    Parameters
    ----------
    x : array_like
        Input array.
    axes : int or shape tuple, optional
        Axes over which to calculate.  Defaults to None, which shifts all axes.
    
    Returns
    -------
    y : ndarray
        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.]])
",function,"('(x, axes=None)',)",scipy,1.1.0,scipy.fftpack.helper.ifftshift,fftpack.helper,ifftshift,"Python Library Documentation: function ifftshift in module numpy.fft.helper

ifftshift(x, axes=None)
    The inverse of `fftshift`. Although identical for even-length `x`, the
    functions differ by one sample for odd-length `x`.
    
    Parameters
    ----------
    x : array_like
        Input array.
    axes : int or shape tuple, optional
        Axes over which to calculate.  Defaults to None, which shifts all axes.
    
    Returns
    -------
    y : ndarray
        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.]])
",function,"('x', 'axes')","(nan, None)","(nan, 'NoneType')","('arg_info', 'arg_info')","('(x, axes=None)',)"
scipy,1.1.0,scipy.fftpack.helper.next_fast_len,fftpack.helper,next_fast_len,"Python Library Documentation: function next_fast_len in module scipy.fftpack.helper

next_fast_len(target)
    Find the next fast size of input data to `fft`, for zero-padding, etc.
    
    SciPy's FFTPACK has efficient functions for radix {2, 3, 4, 5}, so this
    returns the next composite of the prime factors 2, 3, and 5 which is
    greater than or equal to `target`. (These are also known as 5-smooth
    numbers, regular numbers, or Hamming numbers.)
    
    Parameters
    ----------
    target : int
        Length to start searching from.  Must be a positive integer.
    
    Returns
    -------
    out : int
        The first 5-smooth number greater than or equal to `target`.
    
    Notes
    -----
    .. versionadded:: 0.18.0
    
    Examples
    --------
    On a particular machine, an FFT of prime length takes 133 ms:
    
    >>> from scipy import fftpack
    >>> min_len = 10007  # prime length is worst case for speed
    >>> a = np.random.randn(min_len)
    >>> b = fftpack.fft(a)
    
    Zero-padding to the next 5-smooth length reduces computation time to
    211 us, a speedup of 630 times:
    
    >>> fftpack.helper.next_fast_len(min_len)
    10125
    >>> b = fftpack.fft(a, 10125)
    
    Rounding up to the next power of 2 is not optimal, taking 367 us to
    compute, 1.7 times as long as the 5-smooth size:
    
    >>> b = fftpack.fft(a, 16384)
",function,"('(target)',)",scipy,1.1.0,scipy.fftpack.helper.next_fast_len,fftpack.helper,next_fast_len,"Python Library Documentation: function next_fast_len in module scipy.fftpack.helper

next_fast_len(target)
    Find the next fast size of input data to `fft`, for zero-padding, etc.
    
    SciPy's FFTPACK has efficient functions for radix {2, 3, 4, 5}, so this
    returns the next composite of the prime factors 2, 3, and 5 which is
    greater than or equal to `target`. (These are also known as 5-smooth
    numbers, regular numbers, or Hamming numbers.)
    
    Parameters
    ----------
    target : int
        Length to start searching from.  Must be a positive integer.
    
    Returns
    -------
    out : int
        The first 5-smooth number greater than or equal to `target`.
    
    Notes
    -----
    .. versionadded:: 0.18.0
    
    Examples
    --------
    On a particular machine, an FFT of prime length takes 133 ms:
    
    >>> from scipy import fftpack
    >>> min_len = 10007  # prime length is worst case for speed
    >>> a = np.random.randn(min_len)
    >>> b = fftpack.fft(a)
    
    Zero-padding to the next 5-smooth length reduces computation time to
    211 us, a speedup of 630 times:
    
    >>> fftpack.helper.next_fast_len(min_len)
    10125
    >>> b = fftpack.fft(a, 10125)
    
    Rounding up to the next power of 2 is not optimal, taking 367 us to
    compute, 1.7 times as long as the 5-smooth size:
    
    >>> b = fftpack.fft(a, 16384)
",function,"('target',)","(nan,)","(nan,)","('arg_info',)","('(target)',)"
scipy,1.1.0,scipy.fftpack.helper.rfftfreq,fftpack.helper,rfftfreq,"Python Library Documentation: function rfftfreq in module scipy.fftpack.helper

rfftfreq(n, d=1.0)
    DFT sample frequencies (for usage with rfft, irfft).
    
    The returned float array contains the frequency bins in
    cycles/unit (with zero at the start) given a window length `n` and a
    sample spacing `d`::
    
      f = [0,1,1,2,2,...,n/2-1,n/2-1,n/2]/(d*n)   if n is even
      f = [0,1,1,2,2,...,n/2-1,n/2-1,n/2,n/2]/(d*n)   if n is odd
    
    Parameters
    ----------
    n : int
        Window length.
    d : scalar, optional
        Sample spacing. Default is 1.
    
    Returns
    -------
    out : ndarray
        The array of length `n`, containing the sample frequencies.
    
    Examples
    --------
    >>> from scipy import fftpack
    >>> sig = np.array([-2, 8, 6, 4, 1, 0, 3, 5], dtype=float)
    >>> sig_fft = fftpack.rfft(sig)
    >>> n = sig_fft.size
    >>> timestep = 0.1
    >>> freq = fftpack.rfftfreq(n, d=timestep)
    >>> freq
    array([ 0.  ,  1.25,  1.25,  2.5 ,  2.5 ,  3.75,  3.75,  5.  ])
",function,"('(n, d=1.0)',)",scipy,1.1.0,scipy.fftpack.helper.rfftfreq,fftpack.helper,rfftfreq,"Python Library Documentation: function rfftfreq in module scipy.fftpack.helper

rfftfreq(n, d=1.0)
    DFT sample frequencies (for usage with rfft, irfft).
    
    The returned float array contains the frequency bins in
    cycles/unit (with zero at the start) given a window length `n` and a
    sample spacing `d`::
    
      f = [0,1,1,2,2,...,n/2-1,n/2-1,n/2]/(d*n)   if n is even
      f = [0,1,1,2,2,...,n/2-1,n/2-1,n/2,n/2]/(d*n)   if n is odd
    
    Parameters
    ----------
    n : int
        Window length.
    d : scalar, optional
        Sample spacing. Default is 1.
    
    Returns
    -------
    out : ndarray
        The array of length `n`, containing the sample frequencies.
    
    Examples
    --------
    >>> from scipy import fftpack
    >>> sig = np.array([-2, 8, 6, 4, 1, 0, 3, 5], dtype=float)
    >>> sig_fft = fftpack.rfft(sig)
    >>> n = sig_fft.size
    >>> timestep = 0.1
    >>> freq = fftpack.rfftfreq(n, d=timestep)
    >>> freq
    array([ 0.  ,  1.25,  1.25,  2.5 ,  2.5 ,  3.75,  3.75,  5.  ])
",function,"('n', 'd')","(nan, 1.0)","(nan, 'float')","('arg_info', 'arg_info')","('(n, d=1.0)',)"
scipy,1.1.0,scipy.fftpack.pseudo_diffs._datacopied,fftpack.pseudo_diffs,_datacopied,"Python Library Documentation: function _datacopied in module scipy.fftpack.basic

_datacopied(arr, original)
    Strict check for `arr` not sharing any data with `original`,
    under the assumption that arr = asarray(original)
",function,"('(arr, original)',)",scipy,1.1.0,scipy.fftpack.pseudo_diffs._datacopied,fftpack.pseudo_diffs,_datacopied,"Python Library Documentation: function _datacopied in module scipy.fftpack.basic

_datacopied(arr, original)
    Strict check for `arr` not sharing any data with `original`,
    under the assumption that arr = asarray(original)
",function,"('arr', 'original')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(arr, original)',)"
scipy,1.1.0,scipy.fftpack.pseudo_diffs.asarray,fftpack.pseudo_diffs,asarray,"Python Library Documentation: function asarray in module numpy.core.numeric

asarray(a, dtype=None, order=None)
    Convert the input to an array.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
        Whether to use row-major (C-style) or
        column-major (Fortran-style) memory representation.
        Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray with matching dtype and order.  If `a` is a
        subclass of ndarray, a base class ndarray is returned.
    
    See Also
    --------
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    asarray_chkfinite : Similar function which checks input for NaNs and Infs.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array:
    
    >>> a = [1, 2]
    >>> np.asarray(a)
    array([1, 2])
    
    Existing arrays are not copied:
    
    >>> a = np.array([1, 2])
    >>> np.asarray(a) is a
    True
    
    If `dtype` is set, array is copied only if dtype does not match:
    
    >>> a = np.array([1, 2], dtype=np.float32)
    >>> np.asarray(a, dtype=np.float32) is a
    True
    >>> np.asarray(a, dtype=np.float64) is a
    False
    
    Contrary to `asanyarray`, ndarray subclasses are not passed through:
    
    >>> issubclass(np.matrix, np.ndarray)
    True
    >>> a = np.matrix([[1, 2]])
    >>> np.asarray(a) is a
    False
    >>> np.asanyarray(a) is a
    True
",function,"('(a, dtype=None, order=None)',)",scipy,1.1.0,scipy.fftpack.pseudo_diffs.asarray,fftpack.pseudo_diffs,asarray,"Python Library Documentation: function asarray in module numpy.core.numeric

asarray(a, dtype=None, order=None)
    Convert the input to an array.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
        Whether to use row-major (C-style) or
        column-major (Fortran-style) memory representation.
        Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray with matching dtype and order.  If `a` is a
        subclass of ndarray, a base class ndarray is returned.
    
    See Also
    --------
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    asarray_chkfinite : Similar function which checks input for NaNs and Infs.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array:
    
    >>> a = [1, 2]
    >>> np.asarray(a)
    array([1, 2])
    
    Existing arrays are not copied:
    
    >>> a = np.array([1, 2])
    >>> np.asarray(a) is a
    True
    
    If `dtype` is set, array is copied only if dtype does not match:
    
    >>> a = np.array([1, 2], dtype=np.float32)
    >>> np.asarray(a, dtype=np.float32) is a
    True
    >>> np.asarray(a, dtype=np.float64) is a
    False
    
    Contrary to `asanyarray`, ndarray subclasses are not passed through:
    
    >>> issubclass(np.matrix, np.ndarray)
    True
    >>> a = np.matrix([[1, 2]])
    >>> np.asarray(a) is a
    False
    >>> np.asanyarray(a) is a
    True
",function,"('a', 'dtype', 'order')","(nan, None, None)","(nan, 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(a, dtype=None, order=None)',)"
scipy,1.1.0,scipy.fftpack.pseudo_diffs.cc_diff,fftpack.pseudo_diffs,cc_diff,"Python Library Documentation: function cc_diff in module scipy.fftpack.pseudo_diffs

cc_diff(x, a, b, period=None, _cache={})
    Return (a,b)-cosh/cosh pseudo-derivative of a periodic sequence.
    
    If x_j and y_j are Fourier coefficients of periodic functions x
    and y, respectively, then::
    
      y_j = cosh(j*a*2*pi/period)/cosh(j*b*2*pi/period) * x_j
    
    Parameters
    ----------
    x : array_like
        The array to take the pseudo-derivative from.
    a,b : float
        Defines the parameters of the sinh/sinh pseudo-differential
        operator.
    period : float, optional
        The period of the sequence x. Default is ``2*pi``.
    
    Returns
    -------
    cc_diff : ndarray
        Pseudo-derivative of periodic sequence `x`.
    
    Notes
    -----
    ``cc_diff(cc_diff(x,a,b),b,a) == x``
",function,"('(x, a, b, period=None, _cache={})',)",scipy,1.1.0,scipy.fftpack.pseudo_diffs.cc_diff,fftpack.pseudo_diffs,cc_diff,"Python Library Documentation: function cc_diff in module scipy.fftpack.pseudo_diffs

cc_diff(x, a, b, period=None, _cache={})
    Return (a,b)-cosh/cosh pseudo-derivative of a periodic sequence.
    
    If x_j and y_j are Fourier coefficients of periodic functions x
    and y, respectively, then::
    
      y_j = cosh(j*a*2*pi/period)/cosh(j*b*2*pi/period) * x_j
    
    Parameters
    ----------
    x : array_like
        The array to take the pseudo-derivative from.
    a,b : float
        Defines the parameters of the sinh/sinh pseudo-differential
        operator.
    period : float, optional
        The period of the sequence x. Default is ``2*pi``.
    
    Returns
    -------
    cc_diff : ndarray
        Pseudo-derivative of periodic sequence `x`.
    
    Notes
    -----
    ``cc_diff(cc_diff(x,a,b),b,a) == x``
",function,"('x', 'a', 'b', 'period', '_cache')","(nan, nan, nan, None, {})","(nan, nan, nan, 'NoneType', 'dict')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, a, b, period=None, _cache={})',)"
scipy,1.1.0,scipy.fftpack.pseudo_diffs.cs_diff,fftpack.pseudo_diffs,cs_diff,"Python Library Documentation: function cs_diff in module scipy.fftpack.pseudo_diffs

cs_diff(x, a, b, period=None, _cache={})
    Return (a,b)-cosh/sinh pseudo-derivative of a periodic sequence.
    
    If ``x_j`` and ``y_j`` are Fourier coefficients of periodic functions x
    and y, respectively, then::
    
      y_j = -sqrt(-1)*cosh(j*a*2*pi/period)/sinh(j*b*2*pi/period) * x_j
      y_0 = 0
    
    Parameters
    ----------
    x : array_like
        The array to take the pseudo-derivative from.
    a, b : float
        Defines the parameters of the cosh/sinh pseudo-differential
        operator.
    period : float, optional
        The period of the sequence. Default period is ``2*pi``.
    
    Returns
    -------
    cs_diff : ndarray
        Pseudo-derivative of periodic sequence `x`.
    
    Notes
    -----
    For even len(`x`), the Nyquist mode of `x` is taken as zero.
",function,"('(x, a, b, period=None, _cache={})',)",scipy,1.1.0,scipy.fftpack.pseudo_diffs.cs_diff,fftpack.pseudo_diffs,cs_diff,"Python Library Documentation: function cs_diff in module scipy.fftpack.pseudo_diffs

cs_diff(x, a, b, period=None, _cache={})
    Return (a,b)-cosh/sinh pseudo-derivative of a periodic sequence.
    
    If ``x_j`` and ``y_j`` are Fourier coefficients of periodic functions x
    and y, respectively, then::
    
      y_j = -sqrt(-1)*cosh(j*a*2*pi/period)/sinh(j*b*2*pi/period) * x_j
      y_0 = 0
    
    Parameters
    ----------
    x : array_like
        The array to take the pseudo-derivative from.
    a, b : float
        Defines the parameters of the cosh/sinh pseudo-differential
        operator.
    period : float, optional
        The period of the sequence. Default period is ``2*pi``.
    
    Returns
    -------
    cs_diff : ndarray
        Pseudo-derivative of periodic sequence `x`.
    
    Notes
    -----
    For even len(`x`), the Nyquist mode of `x` is taken as zero.
",function,"('x', 'a', 'b', 'period', '_cache')","(nan, nan, nan, None, {})","(nan, nan, nan, 'NoneType', 'dict')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, a, b, period=None, _cache={})',)"
scipy,1.1.0,scipy.fftpack.pseudo_diffs.diff,fftpack.pseudo_diffs,diff,"Python Library Documentation: function diff in module scipy.fftpack.pseudo_diffs

diff(x, order=1, period=None, _cache={})
    Return k-th derivative (or integral) of a periodic sequence x.
    
    If x_j and y_j are Fourier coefficients of periodic functions x
    and y, respectively, then::
    
      y_j = pow(sqrt(-1)*j*2*pi/period, order) * x_j
      y_0 = 0 if order is not 0.
    
    Parameters
    ----------
    x : array_like
        Input array.
    order : int, optional
        The order of differentiation. Default order is 1. If order is
        negative, then integration is carried out under the assumption
        that ``x_0 == 0``.
    period : float, optional
        The assumed period of the sequence. Default is ``2*pi``.
    
    Notes
    -----
    If ``sum(x, axis=0) = 0`` then ``diff(diff(x, k), -k) == x`` (within
    numerical accuracy).
    
    For odd order and even ``len(x)``, the Nyquist mode is taken zero.
",function,"('(x, order=1, period=None, _cache={})',)",scipy,1.1.0,scipy.fftpack.pseudo_diffs.diff,fftpack.pseudo_diffs,diff,"Python Library Documentation: function diff in module scipy.fftpack.pseudo_diffs

diff(x, order=1, period=None, _cache={})
    Return k-th derivative (or integral) of a periodic sequence x.
    
    If x_j and y_j are Fourier coefficients of periodic functions x
    and y, respectively, then::
    
      y_j = pow(sqrt(-1)*j*2*pi/period, order) * x_j
      y_0 = 0 if order is not 0.
    
    Parameters
    ----------
    x : array_like
        Input array.
    order : int, optional
        The order of differentiation. Default order is 1. If order is
        negative, then integration is carried out under the assumption
        that ``x_0 == 0``.
    period : float, optional
        The assumed period of the sequence. Default is ``2*pi``.
    
    Notes
    -----
    If ``sum(x, axis=0) = 0`` then ``diff(diff(x, k), -k) == x`` (within
    numerical accuracy).
    
    For odd order and even ``len(x)``, the Nyquist mode is taken zero.
",function,"('x', 'order', 'period', '_cache')","(nan, 1, None, {})","(nan, 'int', 'NoneType', 'dict')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, order=1, period=None, _cache={})',)"
scipy,1.1.0,scipy.fftpack.pseudo_diffs.hilbert,fftpack.pseudo_diffs,hilbert,"Python Library Documentation: function hilbert in module scipy.fftpack.pseudo_diffs

hilbert(x, _cache={})
    Return Hilbert transform of a periodic sequence x.
    
    If x_j and y_j are Fourier coefficients of periodic functions x
    and y, respectively, then::
    
      y_j = sqrt(-1)*sign(j) * x_j
      y_0 = 0
    
    Parameters
    ----------
    x : array_like
        The input array, should be periodic.
    _cache : dict, optional
        Dictionary that contains the kernel used to do a convolution with.
    
    Returns
    -------
    y : ndarray
        The transformed input.
    
    See Also
    --------
    scipy.signal.hilbert : Compute the analytic signal, using the Hilbert
                           transform.
    
    Notes
    -----
    If ``sum(x, axis=0) == 0`` then ``hilbert(ihilbert(x)) == x``.
    
    For even len(x), the Nyquist mode of x is taken zero.
    
    The sign of the returned transform does not have a factor -1 that is more
    often than not found in the definition of the Hilbert transform.  Note also
    that `scipy.signal.hilbert` does have an extra -1 factor compared to this
    function.
",function,"('(x, _cache={})',)",scipy,1.1.0,scipy.fftpack.pseudo_diffs.hilbert,fftpack.pseudo_diffs,hilbert,"Python Library Documentation: function hilbert in module scipy.fftpack.pseudo_diffs

hilbert(x, _cache={})
    Return Hilbert transform of a periodic sequence x.
    
    If x_j and y_j are Fourier coefficients of periodic functions x
    and y, respectively, then::
    
      y_j = sqrt(-1)*sign(j) * x_j
      y_0 = 0
    
    Parameters
    ----------
    x : array_like
        The input array, should be periodic.
    _cache : dict, optional
        Dictionary that contains the kernel used to do a convolution with.
    
    Returns
    -------
    y : ndarray
        The transformed input.
    
    See Also
    --------
    scipy.signal.hilbert : Compute the analytic signal, using the Hilbert
                           transform.
    
    Notes
    -----
    If ``sum(x, axis=0) == 0`` then ``hilbert(ihilbert(x)) == x``.
    
    For even len(x), the Nyquist mode of x is taken zero.
    
    The sign of the returned transform does not have a factor -1 that is more
    often than not found in the definition of the Hilbert transform.  Note also
    that `scipy.signal.hilbert` does have an extra -1 factor compared to this
    function.
",function,"('x', '_cache')","(nan, {})","(nan, 'dict')","('arg_info', 'arg_info')","('(x, _cache={})',)"
scipy,1.1.0,scipy.fftpack.pseudo_diffs.ihilbert,fftpack.pseudo_diffs,ihilbert,"Python Library Documentation: function ihilbert in module scipy.fftpack.pseudo_diffs

ihilbert(x)
    Return inverse Hilbert transform of a periodic sequence x.
    
    If ``x_j`` and ``y_j`` are Fourier coefficients of periodic functions x
    and y, respectively, then::
    
      y_j = -sqrt(-1)*sign(j) * x_j
      y_0 = 0
",function,"('(x)',)",scipy,1.1.0,scipy.fftpack.pseudo_diffs.ihilbert,fftpack.pseudo_diffs,ihilbert,"Python Library Documentation: function ihilbert in module scipy.fftpack.pseudo_diffs

ihilbert(x)
    Return inverse Hilbert transform of a periodic sequence x.
    
    If ``x_j`` and ``y_j`` are Fourier coefficients of periodic functions x
    and y, respectively, then::
    
      y_j = -sqrt(-1)*sign(j) * x_j
      y_0 = 0
",function,"('x',)","(nan,)","(nan,)","('arg_info',)","('(x)',)"
scipy,1.1.0,scipy.fftpack.pseudo_diffs.iscomplexobj,fftpack.pseudo_diffs,iscomplexobj,"Python Library Documentation: function iscomplexobj in module numpy.lib.type_check

iscomplexobj(x)
    Check for a complex type or an array of complex numbers.
    
    The type of the input is checked, not the value. Even if the input
    has an imaginary part equal to zero, `iscomplexobj` evaluates to True.
    
    Parameters
    ----------
    x : any
        The input can be of any type and shape.
    
    Returns
    -------
    iscomplexobj : bool
        The return value, True if `x` is of a complex type or has at least
        one complex element.
    
    See Also
    --------
    isrealobj, iscomplex
    
    Examples
    --------
    >>> np.iscomplexobj(1)
    False
    >>> np.iscomplexobj(1+0j)
    True
    >>> np.iscomplexobj([3, 1+0j, True])
    True
",function,"('(x)',)",scipy,1.1.0,scipy.fftpack.pseudo_diffs.iscomplexobj,fftpack.pseudo_diffs,iscomplexobj,"Python Library Documentation: function iscomplexobj in module numpy.lib.type_check

iscomplexobj(x)
    Check for a complex type or an array of complex numbers.
    
    The type of the input is checked, not the value. Even if the input
    has an imaginary part equal to zero, `iscomplexobj` evaluates to True.
    
    Parameters
    ----------
    x : any
        The input can be of any type and shape.
    
    Returns
    -------
    iscomplexobj : bool
        The return value, True if `x` is of a complex type or has at least
        one complex element.
    
    See Also
    --------
    isrealobj, iscomplex
    
    Examples
    --------
    >>> np.iscomplexobj(1)
    False
    >>> np.iscomplexobj(1+0j)
    True
    >>> np.iscomplexobj([3, 1+0j, True])
    True
",function,"('x',)","(nan,)","(nan,)","('arg_info',)","('(x)',)"
scipy,1.1.0,scipy.fftpack.pseudo_diffs.itilbert,fftpack.pseudo_diffs,itilbert,"Python Library Documentation: function itilbert in module scipy.fftpack.pseudo_diffs

itilbert(x, h, period=None, _cache={})
    Return inverse h-Tilbert transform of a periodic sequence x.
    
    If ``x_j`` and ``y_j`` are Fourier coefficients of periodic functions x
    and y, respectively, then::
    
      y_j = -sqrt(-1)*tanh(j*h*2*pi/period) * x_j
      y_0 = 0
    
    For more details, see `tilbert`.
",function,"('(x, h, period=None, _cache={})',)",scipy,1.1.0,scipy.fftpack.pseudo_diffs.itilbert,fftpack.pseudo_diffs,itilbert,"Python Library Documentation: function itilbert in module scipy.fftpack.pseudo_diffs

itilbert(x, h, period=None, _cache={})
    Return inverse h-Tilbert transform of a periodic sequence x.
    
    If ``x_j`` and ``y_j`` are Fourier coefficients of periodic functions x
    and y, respectively, then::
    
      y_j = -sqrt(-1)*tanh(j*h*2*pi/period) * x_j
      y_0 = 0
    
    For more details, see `tilbert`.
",function,"('x', 'h', 'period', '_cache')","(nan, nan, None, {})","(nan, nan, 'NoneType', 'dict')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, h, period=None, _cache={})',)"
scipy,1.1.0,scipy.fftpack.pseudo_diffs.sc_diff,fftpack.pseudo_diffs,sc_diff,"Python Library Documentation: function sc_diff in module scipy.fftpack.pseudo_diffs

sc_diff(x, a, b, period=None, _cache={})
    Return (a,b)-sinh/cosh pseudo-derivative of a periodic sequence x.
    
    If x_j and y_j are Fourier coefficients of periodic functions x
    and y, respectively, then::
    
      y_j = sqrt(-1)*sinh(j*a*2*pi/period)/cosh(j*b*2*pi/period) * x_j
      y_0 = 0
    
    Parameters
    ----------
    x : array_like
        Input array.
    a,b : float
        Defines the parameters of the sinh/cosh pseudo-differential
        operator.
    period : float, optional
        The period of the sequence x. Default is 2*pi.
    
    Notes
    -----
    ``sc_diff(cs_diff(x,a,b),b,a) == x``
    For even ``len(x)``, the Nyquist mode of x is taken as zero.
",function,"('(x, a, b, period=None, _cache={})',)",scipy,1.1.0,scipy.fftpack.pseudo_diffs.sc_diff,fftpack.pseudo_diffs,sc_diff,"Python Library Documentation: function sc_diff in module scipy.fftpack.pseudo_diffs

sc_diff(x, a, b, period=None, _cache={})
    Return (a,b)-sinh/cosh pseudo-derivative of a periodic sequence x.
    
    If x_j and y_j are Fourier coefficients of periodic functions x
    and y, respectively, then::
    
      y_j = sqrt(-1)*sinh(j*a*2*pi/period)/cosh(j*b*2*pi/period) * x_j
      y_0 = 0
    
    Parameters
    ----------
    x : array_like
        Input array.
    a,b : float
        Defines the parameters of the sinh/cosh pseudo-differential
        operator.
    period : float, optional
        The period of the sequence x. Default is 2*pi.
    
    Notes
    -----
    ``sc_diff(cs_diff(x,a,b),b,a) == x``
    For even ``len(x)``, the Nyquist mode of x is taken as zero.
",function,"('x', 'a', 'b', 'period', '_cache')","(nan, nan, nan, None, {})","(nan, nan, nan, 'NoneType', 'dict')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, a, b, period=None, _cache={})',)"
scipy,1.1.0,scipy.fftpack.pseudo_diffs.shift,fftpack.pseudo_diffs,shift,"Python Library Documentation: function shift in module scipy.fftpack.pseudo_diffs

shift(x, a, period=None, _cache={})
    Shift periodic sequence x by a: y(u) = x(u+a).
    
    If x_j and y_j are Fourier coefficients of periodic functions x
    and y, respectively, then::
    
          y_j = exp(j*a*2*pi/period*sqrt(-1)) * x_f
    
    Parameters
    ----------
    x : array_like
        The array to take the pseudo-derivative from.
    a : float
        Defines the parameters of the sinh/sinh pseudo-differential
    period : float, optional
        The period of the sequences x and y. Default period is ``2*pi``.
",function,"('(x, a, period=None, _cache={})',)",scipy,1.1.0,scipy.fftpack.pseudo_diffs.shift,fftpack.pseudo_diffs,shift,"Python Library Documentation: function shift in module scipy.fftpack.pseudo_diffs

shift(x, a, period=None, _cache={})
    Shift periodic sequence x by a: y(u) = x(u+a).
    
    If x_j and y_j are Fourier coefficients of periodic functions x
    and y, respectively, then::
    
          y_j = exp(j*a*2*pi/period*sqrt(-1)) * x_f
    
    Parameters
    ----------
    x : array_like
        The array to take the pseudo-derivative from.
    a : float
        Defines the parameters of the sinh/sinh pseudo-differential
    period : float, optional
        The period of the sequences x and y. Default period is ``2*pi``.
",function,"('x', 'a', 'period', '_cache')","(nan, nan, None, {})","(nan, nan, 'NoneType', 'dict')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, a, period=None, _cache={})',)"
scipy,1.1.0,scipy.fftpack.pseudo_diffs.ss_diff,fftpack.pseudo_diffs,ss_diff,"Python Library Documentation: function ss_diff in module scipy.fftpack.pseudo_diffs

ss_diff(x, a, b, period=None, _cache={})
    Return (a,b)-sinh/sinh pseudo-derivative of a periodic sequence x.
    
    If x_j and y_j are Fourier coefficients of periodic functions x
    and y, respectively, then::
    
      y_j = sinh(j*a*2*pi/period)/sinh(j*b*2*pi/period) * x_j
      y_0 = a/b * x_0
    
    Parameters
    ----------
    x : array_like
        The array to take the pseudo-derivative from.
    a,b
        Defines the parameters of the sinh/sinh pseudo-differential
        operator.
    period : float, optional
        The period of the sequence x. Default is ``2*pi``.
    
    Notes
    -----
    ``ss_diff(ss_diff(x,a,b),b,a) == x``
",function,"('(x, a, b, period=None, _cache={})',)",scipy,1.1.0,scipy.fftpack.pseudo_diffs.ss_diff,fftpack.pseudo_diffs,ss_diff,"Python Library Documentation: function ss_diff in module scipy.fftpack.pseudo_diffs

ss_diff(x, a, b, period=None, _cache={})
    Return (a,b)-sinh/sinh pseudo-derivative of a periodic sequence x.
    
    If x_j and y_j are Fourier coefficients of periodic functions x
    and y, respectively, then::
    
      y_j = sinh(j*a*2*pi/period)/sinh(j*b*2*pi/period) * x_j
      y_0 = a/b * x_0
    
    Parameters
    ----------
    x : array_like
        The array to take the pseudo-derivative from.
    a,b
        Defines the parameters of the sinh/sinh pseudo-differential
        operator.
    period : float, optional
        The period of the sequence x. Default is ``2*pi``.
    
    Notes
    -----
    ``ss_diff(ss_diff(x,a,b),b,a) == x``
",function,"('x', 'a', 'b', 'period', '_cache')","(nan, nan, nan, None, {})","(nan, nan, nan, 'NoneType', 'dict')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, a, b, period=None, _cache={})',)"
scipy,1.1.0,scipy.fftpack.pseudo_diffs.tilbert,fftpack.pseudo_diffs,tilbert,"Python Library Documentation: function tilbert in module scipy.fftpack.pseudo_diffs

tilbert(x, h, period=None, _cache={})
    Return h-Tilbert transform of a periodic sequence x.
    
    If x_j and y_j are Fourier coefficients of periodic functions x
    and y, respectively, then::
    
        y_j = sqrt(-1)*coth(j*h*2*pi/period) * x_j
        y_0 = 0
    
    Parameters
    ----------
    x : array_like
        The input array to transform.
    h : float
        Defines the parameter of the Tilbert transform.
    period : float, optional
        The assumed period of the sequence.  Default period is ``2*pi``.
    
    Returns
    -------
    tilbert : ndarray
        The result of the transform.
    
    Notes
    -----
    If ``sum(x, axis=0) == 0`` and ``n = len(x)`` is odd then
    ``tilbert(itilbert(x)) == x``.
    
    If ``2 * pi * h / period`` is approximately 10 or larger, then
    numerically ``tilbert == hilbert``
    (theoretically oo-Tilbert == Hilbert).
    
    For even ``len(x)``, the Nyquist mode of ``x`` is taken zero.
",function,"('(x, h, period=None, _cache={})',)",scipy,1.1.0,scipy.fftpack.pseudo_diffs.tilbert,fftpack.pseudo_diffs,tilbert,"Python Library Documentation: function tilbert in module scipy.fftpack.pseudo_diffs

tilbert(x, h, period=None, _cache={})
    Return h-Tilbert transform of a periodic sequence x.
    
    If x_j and y_j are Fourier coefficients of periodic functions x
    and y, respectively, then::
    
        y_j = sqrt(-1)*coth(j*h*2*pi/period) * x_j
        y_0 = 0
    
    Parameters
    ----------
    x : array_like
        The input array to transform.
    h : float
        Defines the parameter of the Tilbert transform.
    period : float, optional
        The assumed period of the sequence.  Default period is ``2*pi``.
    
    Returns
    -------
    tilbert : ndarray
        The result of the transform.
    
    Notes
    -----
    If ``sum(x, axis=0) == 0`` and ``n = len(x)`` is odd then
    ``tilbert(itilbert(x)) == x``.
    
    If ``2 * pi * h / period`` is approximately 10 or larger, then
    numerically ``tilbert == hilbert``
    (theoretically oo-Tilbert == Hilbert).
    
    For even ``len(x)``, the Nyquist mode of ``x`` is taken zero.
",function,"('x', 'h', 'period', '_cache')","(nan, nan, None, {})","(nan, nan, 'NoneType', 'dict')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, h, period=None, _cache={})',)"
scipy,1.1.0,scipy.fftpack.realtransforms.__fix_shape,fftpack.realtransforms,__fix_shape,"Python Library Documentation: function __fix_shape in module scipy.fftpack.realtransforms

__fix_shape(x, n, axis, dct_or_dst)
",function,"('(x, n, axis, dct_or_dst)',)",scipy,1.1.0,scipy.fftpack.realtransforms.__fix_shape,fftpack.realtransforms,__fix_shape,"Python Library Documentation: function __fix_shape in module scipy.fftpack.realtransforms

__fix_shape(x, n, axis, dct_or_dst)
",function,"('x', 'n', 'axis', 'dct_or_dst')","(nan, nan, nan, nan)","(nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, n, axis, dct_or_dst)',)"
scipy,1.1.0,scipy.fftpack.realtransforms._asfarray,fftpack.realtransforms,_asfarray,"Python Library Documentation: function _asfarray in module scipy.fftpack.basic

_asfarray(x)
    Like numpy asfarray, except that it does not modify x dtype if x is
    already an array with a float dtype, and do not cast complex types to
    real.
",function,"('(x)',)",scipy,1.1.0,scipy.fftpack.realtransforms._asfarray,fftpack.realtransforms,_asfarray,"Python Library Documentation: function _asfarray in module scipy.fftpack.basic

_asfarray(x)
    Like numpy asfarray, except that it does not modify x dtype if x is
    already an array with a float dtype, and do not cast complex types to
    real.
",function,"('x',)","(nan,)","(nan,)","('arg_info',)","('(x)',)"
scipy,1.1.0,scipy.fftpack.realtransforms._datacopied,fftpack.realtransforms,_datacopied,"Python Library Documentation: function _datacopied in module scipy.fftpack.basic

_datacopied(arr, original)
    Strict check for `arr` not sharing any data with `original`,
    under the assumption that arr = asarray(original)
",function,"('(arr, original)',)",scipy,1.1.0,scipy.fftpack.realtransforms._datacopied,fftpack.realtransforms,_datacopied,"Python Library Documentation: function _datacopied in module scipy.fftpack.basic

_datacopied(arr, original)
    Strict check for `arr` not sharing any data with `original`,
    under the assumption that arr = asarray(original)
",function,"('arr', 'original')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(arr, original)',)"
scipy,1.1.0,scipy.fftpack.realtransforms._dct,fftpack.realtransforms,_dct,"Python Library Documentation: function _dct in module scipy.fftpack.realtransforms

_dct(x, type, n=None, axis=-1, overwrite_x=False, normalize=None)
    Return Discrete Cosine Transform of arbitrary type sequence x.
    
    Parameters
    ----------
    x : array_like
        input array.
    n : int, optional
        Length of the transform.  If ``n < x.shape[axis]``, `x` is
        truncated.  If ``n > x.shape[axis]``, `x` is zero-padded. The
        default results in ``n = x.shape[axis]``.
    axis : int, optional
        Axis along which the dct is computed; the default is over the
        last axis (i.e., ``axis=-1``).
    overwrite_x : bool, optional
        If True, the contents of `x` can be destroyed; the default is False.
    
    Returns
    -------
    z : ndarray
",function,"('(x, type, n=None, axis=-1, overwrite_x=False, normalize=None)',)",scipy,1.1.0,scipy.fftpack.realtransforms._dct,fftpack.realtransforms,_dct,"Python Library Documentation: function _dct in module scipy.fftpack.realtransforms

_dct(x, type, n=None, axis=-1, overwrite_x=False, normalize=None)
    Return Discrete Cosine Transform of arbitrary type sequence x.
    
    Parameters
    ----------
    x : array_like
        input array.
    n : int, optional
        Length of the transform.  If ``n < x.shape[axis]``, `x` is
        truncated.  If ``n > x.shape[axis]``, `x` is zero-padded. The
        default results in ``n = x.shape[axis]``.
    axis : int, optional
        Axis along which the dct is computed; the default is over the
        last axis (i.e., ``axis=-1``).
    overwrite_x : bool, optional
        If True, the contents of `x` can be destroyed; the default is False.
    
    Returns
    -------
    z : ndarray
",function,"('x', 'type', 'n', 'axis', 'overwrite_x', 'normalize')","(nan, nan, None, -1, False, None)","(nan, nan, 'NoneType', 'int', 'bool', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, type, n=None, axis=-1, overwrite_x=False, normalize=None)',)"
scipy,1.1.0,scipy.fftpack.realtransforms._dst,fftpack.realtransforms,_dst,"Python Library Documentation: function _dst in module scipy.fftpack.realtransforms

_dst(x, type, n=None, axis=-1, overwrite_x=False, normalize=None)
    Return Discrete Sine Transform of arbitrary type sequence x.
    
    Parameters
    ----------
    x : array_like
        input array.
    n : int, optional
        Length of the transform.
    axis : int, optional
        Axis along which the dst is computed. (default=-1)
    overwrite_x : bool, optional
        If True the contents of x can be destroyed. (default=False)
    
    Returns
    -------
    z : real ndarray
",function,"('(x, type, n=None, axis=-1, overwrite_x=False, normalize=None)',)",scipy,1.1.0,scipy.fftpack.realtransforms._dst,fftpack.realtransforms,_dst,"Python Library Documentation: function _dst in module scipy.fftpack.realtransforms

_dst(x, type, n=None, axis=-1, overwrite_x=False, normalize=None)
    Return Discrete Sine Transform of arbitrary type sequence x.
    
    Parameters
    ----------
    x : array_like
        input array.
    n : int, optional
        Length of the transform.
    axis : int, optional
        Axis along which the dst is computed. (default=-1)
    overwrite_x : bool, optional
        If True the contents of x can be destroyed. (default=False)
    
    Returns
    -------
    z : real ndarray
",function,"('x', 'type', 'n', 'axis', 'overwrite_x', 'normalize')","(nan, nan, None, -1, False, None)","(nan, nan, 'NoneType', 'int', 'bool', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, type, n=None, axis=-1, overwrite_x=False, normalize=None)',)"
scipy,1.1.0,scipy.fftpack.realtransforms._eval_fun,fftpack.realtransforms,_eval_fun,"Python Library Documentation: function _eval_fun in module scipy.fftpack.realtransforms

_eval_fun(f, tmp, n, axis, nm, overwrite_x)
",function,"('(f, tmp, n, axis, nm, overwrite_x)',)",scipy,1.1.0,scipy.fftpack.realtransforms._eval_fun,fftpack.realtransforms,_eval_fun,"Python Library Documentation: function _eval_fun in module scipy.fftpack.realtransforms

_eval_fun(f, tmp, n, axis, nm, overwrite_x)
",function,"('f', 'tmp', 'n', 'axis', 'nm', 'overwrite_x')","(nan, nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(f, tmp, n, axis, nm, overwrite_x)',)"
scipy,1.1.0,scipy.fftpack.realtransforms._fix_shape,fftpack.realtransforms,_fix_shape,"Python Library Documentation: function _fix_shape in module scipy.fftpack.basic

_fix_shape(x, n, axis)
    Internal auxiliary function for _raw_fft, _raw_fftnd.
",function,"('(x, n, axis)',)",scipy,1.1.0,scipy.fftpack.realtransforms._fix_shape,fftpack.realtransforms,_fix_shape,"Python Library Documentation: function _fix_shape in module scipy.fftpack.basic

_fix_shape(x, n, axis)
    Internal auxiliary function for _raw_fft, _raw_fftnd.
",function,"('x', 'n', 'axis')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(x, n, axis)',)"
scipy,1.1.0,scipy.fftpack.realtransforms._get_dct_fun,fftpack.realtransforms,_get_dct_fun,"Python Library Documentation: function _get_dct_fun in module scipy.fftpack.realtransforms

_get_dct_fun(type, dtype)
",function,"('(type, dtype)',)",scipy,1.1.0,scipy.fftpack.realtransforms._get_dct_fun,fftpack.realtransforms,_get_dct_fun,"Python Library Documentation: function _get_dct_fun in module scipy.fftpack.realtransforms

_get_dct_fun(type, dtype)
",function,"('type', 'dtype')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(type, dtype)',)"
scipy,1.1.0,scipy.fftpack.realtransforms._get_dst_fun,fftpack.realtransforms,_get_dst_fun,"Python Library Documentation: function _get_dst_fun in module scipy.fftpack.realtransforms

_get_dst_fun(type, dtype)
",function,"('(type, dtype)',)",scipy,1.1.0,scipy.fftpack.realtransforms._get_dst_fun,fftpack.realtransforms,_get_dst_fun,"Python Library Documentation: function _get_dst_fun in module scipy.fftpack.realtransforms

_get_dst_fun(type, dtype)
",function,"('type', 'dtype')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(type, dtype)',)"
scipy,1.1.0,scipy.fftpack.realtransforms._get_norm_mode,fftpack.realtransforms,_get_norm_mode,"Python Library Documentation: function _get_norm_mode in module scipy.fftpack.realtransforms

_get_norm_mode(normalize)
",function,"('(normalize)',)",scipy,1.1.0,scipy.fftpack.realtransforms._get_norm_mode,fftpack.realtransforms,_get_norm_mode,"Python Library Documentation: function _get_norm_mode in module scipy.fftpack.realtransforms

_get_norm_mode(normalize)
",function,"('normalize',)","(nan,)","(nan,)","('arg_info',)","('(normalize)',)"
scipy,1.1.0,scipy.fftpack.realtransforms._init_nd_shape_and_axes,fftpack.realtransforms,_init_nd_shape_and_axes,"Python Library Documentation: function _init_nd_shape_and_axes in module scipy.fftpack.realtransforms

_init_nd_shape_and_axes(x, shape, axes)
    Handle shape and axes arguments for dctn, idctn, dstn, idstn.
",function,"('(x, shape, axes)',)",scipy,1.1.0,scipy.fftpack.realtransforms._init_nd_shape_and_axes,fftpack.realtransforms,_init_nd_shape_and_axes,"Python Library Documentation: function _init_nd_shape_and_axes in module scipy.fftpack.realtransforms

_init_nd_shape_and_axes(x, shape, axes)
    Handle shape and axes arguments for dctn, idctn, dstn, idstn.
",function,"('x', 'shape', 'axes')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(x, shape, axes)',)"
scipy,1.1.0,scipy.fftpack.realtransforms._raw_dct,fftpack.realtransforms,_raw_dct,"Python Library Documentation: function _raw_dct in module scipy.fftpack.realtransforms

_raw_dct(x0, type, n, axis, nm, overwrite_x)
",function,"('(x0, type, n, axis, nm, overwrite_x)',)",scipy,1.1.0,scipy.fftpack.realtransforms._raw_dct,fftpack.realtransforms,_raw_dct,"Python Library Documentation: function _raw_dct in module scipy.fftpack.realtransforms

_raw_dct(x0, type, n, axis, nm, overwrite_x)
",function,"('x0', 'type', 'n', 'axis', 'nm', 'overwrite_x')","(nan, nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x0, type, n, axis, nm, overwrite_x)',)"
scipy,1.1.0,scipy.fftpack.realtransforms._raw_dst,fftpack.realtransforms,_raw_dst,"Python Library Documentation: function _raw_dst in module scipy.fftpack.realtransforms

_raw_dst(x0, type, n, axis, nm, overwrite_x)
",function,"('(x0, type, n, axis, nm, overwrite_x)',)",scipy,1.1.0,scipy.fftpack.realtransforms._raw_dst,fftpack.realtransforms,_raw_dst,"Python Library Documentation: function _raw_dst in module scipy.fftpack.realtransforms

_raw_dst(x0, type, n, axis, nm, overwrite_x)
",function,"('x0', 'type', 'n', 'axis', 'nm', 'overwrite_x')","(nan, nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x0, type, n, axis, nm, overwrite_x)',)"
scipy,1.1.0,scipy.fftpack.realtransforms.dct,fftpack.realtransforms,dct,"Python Library Documentation: function dct in module scipy.fftpack.realtransforms

dct(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False)
    Return the Discrete Cosine Transform of arbitrary type sequence x.
    
    Parameters
    ----------
    x : array_like
        The input array.
    type : {1, 2, 3}, optional
        Type of the DCT (see Notes). Default type is 2.
    n : int, optional
        Length of the transform.  If ``n < x.shape[axis]``, `x` is
        truncated.  If ``n > x.shape[axis]``, `x` is zero-padded. The
        default results in ``n = x.shape[axis]``.
    axis : int, optional
        Axis along which the dct is computed; the default is over the
        last axis (i.e., ``axis=-1``).
    norm : {None, 'ortho'}, optional
        Normalization mode (see Notes). Default is None.
    overwrite_x : bool, optional
        If True, the contents of `x` can be destroyed; the default is False.
    
    Returns
    -------
    y : ndarray of real
        The transformed input array.
    
    See Also
    --------
    idct : Inverse DCT
    
    Notes
    -----
    For a single dimension array ``x``, ``dct(x, norm='ortho')`` is equal to
    MATLAB ``dct(x)``.
    
    There are theoretically 8 types of the DCT, only the first 3 types are
    implemented in scipy. 'The' DCT generally refers to DCT type 2, and 'the'
    Inverse DCT generally refers to DCT type 3.
    
    **Type I**
    
    There are several definitions of the DCT-I; we use the following
    (for ``norm=None``)::
    
                                         N-2
      y[k] = x[0] + (-1)**k x[N-1] + 2 * sum x[n]*cos(pi*k*n/(N-1))
                                         n=1
    
    Only None is supported as normalization mode for DCT-I. Note also that the
    DCT-I is only supported for input size > 1
    
    **Type II**
    
    There are several definitions of the DCT-II; we use the following
    (for ``norm=None``)::
    
    
                N-1
      y[k] = 2* sum x[n]*cos(pi*k*(2n+1)/(2*N)), 0 <= k < N.
                n=0
    
    If ``norm='ortho'``, ``y[k]`` is multiplied by a scaling factor `f`::
    
      f = sqrt(1/(4*N)) if k = 0,
      f = sqrt(1/(2*N)) otherwise.
    
    Which makes the corresponding matrix of coefficients orthonormal
    (``OO' = Id``).
    
    **Type III**
    
    There are several definitions, we use the following
    (for ``norm=None``)::
    
                        N-1
      y[k] = x[0] + 2 * sum x[n]*cos(pi*(k+0.5)*n/N), 0 <= k < N.
                        n=1
    
    or, for ``norm='ortho'`` and 0 <= k < N::
    
                                          N-1
      y[k] = x[0] / sqrt(N) + sqrt(2/N) * sum x[n]*cos(pi*(k+0.5)*n/N)
                                          n=1
    
    The (unnormalized) DCT-III is the inverse of the (unnormalized) DCT-II, up
    to a factor `2N`. The orthonormalized DCT-III is exactly the inverse of
    the orthonormalized DCT-II.
    
    References
    ----------
    .. [1] 'A Fast Cosine Transform in One and Two Dimensions', by J.
           Makhoul, `IEEE Transactions on acoustics, speech and signal
           processing` vol. 28(1), pp. 27-34,
           http://dx.doi.org/10.1109/TASSP.1980.1163351 (1980).
    .. [2] Wikipedia, ""Discrete cosine transform"",
           http://en.wikipedia.org/wiki/Discrete_cosine_transform
    
    Examples
    --------
    The Type 1 DCT is equivalent to the FFT (though faster) for real,
    even-symmetrical inputs.  The output is also real and even-symmetrical.
    Half of the FFT input is used to generate half of the FFT output:
    
    >>> from scipy.fftpack import fft, dct
    >>> fft(np.array([4., 3., 5., 10., 5., 3.])).real
    array([ 30.,  -8.,   6.,  -2.,   6.,  -8.])
    >>> dct(np.array([4., 3., 5., 10.]), 1)
    array([ 30.,  -8.,   6.,  -2.])
",function,"('(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False)',)",scipy,1.1.0,scipy.fftpack.realtransforms.dct,fftpack.realtransforms,dct,"Python Library Documentation: function dct in module scipy.fftpack.realtransforms

dct(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False)
    Return the Discrete Cosine Transform of arbitrary type sequence x.
    
    Parameters
    ----------
    x : array_like
        The input array.
    type : {1, 2, 3}, optional
        Type of the DCT (see Notes). Default type is 2.
    n : int, optional
        Length of the transform.  If ``n < x.shape[axis]``, `x` is
        truncated.  If ``n > x.shape[axis]``, `x` is zero-padded. The
        default results in ``n = x.shape[axis]``.
    axis : int, optional
        Axis along which the dct is computed; the default is over the
        last axis (i.e., ``axis=-1``).
    norm : {None, 'ortho'}, optional
        Normalization mode (see Notes). Default is None.
    overwrite_x : bool, optional
        If True, the contents of `x` can be destroyed; the default is False.
    
    Returns
    -------
    y : ndarray of real
        The transformed input array.
    
    See Also
    --------
    idct : Inverse DCT
    
    Notes
    -----
    For a single dimension array ``x``, ``dct(x, norm='ortho')`` is equal to
    MATLAB ``dct(x)``.
    
    There are theoretically 8 types of the DCT, only the first 3 types are
    implemented in scipy. 'The' DCT generally refers to DCT type 2, and 'the'
    Inverse DCT generally refers to DCT type 3.
    
    **Type I**
    
    There are several definitions of the DCT-I; we use the following
    (for ``norm=None``)::
    
                                         N-2
      y[k] = x[0] + (-1)**k x[N-1] + 2 * sum x[n]*cos(pi*k*n/(N-1))
                                         n=1
    
    Only None is supported as normalization mode for DCT-I. Note also that the
    DCT-I is only supported for input size > 1
    
    **Type II**
    
    There are several definitions of the DCT-II; we use the following
    (for ``norm=None``)::
    
    
                N-1
      y[k] = 2* sum x[n]*cos(pi*k*(2n+1)/(2*N)), 0 <= k < N.
                n=0
    
    If ``norm='ortho'``, ``y[k]`` is multiplied by a scaling factor `f`::
    
      f = sqrt(1/(4*N)) if k = 0,
      f = sqrt(1/(2*N)) otherwise.
    
    Which makes the corresponding matrix of coefficients orthonormal
    (``OO' = Id``).
    
    **Type III**
    
    There are several definitions, we use the following
    (for ``norm=None``)::
    
                        N-1
      y[k] = x[0] + 2 * sum x[n]*cos(pi*(k+0.5)*n/N), 0 <= k < N.
                        n=1
    
    or, for ``norm='ortho'`` and 0 <= k < N::
    
                                          N-1
      y[k] = x[0] / sqrt(N) + sqrt(2/N) * sum x[n]*cos(pi*(k+0.5)*n/N)
                                          n=1
    
    The (unnormalized) DCT-III is the inverse of the (unnormalized) DCT-II, up
    to a factor `2N`. The orthonormalized DCT-III is exactly the inverse of
    the orthonormalized DCT-II.
    
    References
    ----------
    .. [1] 'A Fast Cosine Transform in One and Two Dimensions', by J.
           Makhoul, `IEEE Transactions on acoustics, speech and signal
           processing` vol. 28(1), pp. 27-34,
           http://dx.doi.org/10.1109/TASSP.1980.1163351 (1980).
    .. [2] Wikipedia, ""Discrete cosine transform"",
           http://en.wikipedia.org/wiki/Discrete_cosine_transform
    
    Examples
    --------
    The Type 1 DCT is equivalent to the FFT (though faster) for real,
    even-symmetrical inputs.  The output is also real and even-symmetrical.
    Half of the FFT input is used to generate half of the FFT output:
    
    >>> from scipy.fftpack import fft, dct
    >>> fft(np.array([4., 3., 5., 10., 5., 3.])).real
    array([ 30.,  -8.,   6.,  -2.,   6.,  -8.])
    >>> dct(np.array([4., 3., 5., 10.]), 1)
    array([ 30.,  -8.,   6.,  -2.])
",function,"('x', 'type', 'n', 'axis', 'norm', 'overwrite_x')","(nan, 2, None, -1, None, False)","(nan, 'int', 'NoneType', 'int', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False)',)"
scipy,1.1.0,scipy.fftpack.realtransforms.dctn,fftpack.realtransforms,dctn,"Python Library Documentation: function dctn in module scipy.fftpack.realtransforms

dctn(x, type=2, shape=None, axes=None, norm=None, overwrite_x=False)
    Return multidimensional Discrete Cosine Transform along the specified axes.
    
    Parameters
    ----------
    x : array_like
        The input array.
    type : {1, 2, 3}, optional
        Type of the DCT (see Notes). Default type is 2.
    shape : tuple of ints, optional
        The shape of the result.  If both `shape` and `axes` (see below) are
        None, `shape` is ``x.shape``; if `shape` is None but `axes` is
        not None, then `shape` is ``scipy.take(x.shape, axes, axis=0)``.
        If ``shape[i] > x.shape[i]``, the i-th dimension is padded with zeros.
        If ``shape[i] < x.shape[i]``, the i-th dimension is truncated to
        length ``shape[i]``.
    axes : tuple or None, optional
        Axes along which the DCT is computed; the default is over all axes.
    norm : {None, 'ortho'}, optional
        Normalization mode (see Notes). Default is None.
    overwrite_x : bool, optional
        If True, the contents of `x` can be destroyed; the default is False.
    
    Returns
    -------
    y : ndarray of real
        The transformed input array.
    
    See Also
    --------
    idctn : Inverse multidimensional DCT
    
    Notes
    -----
    For full details of the DCT types and normalization modes, as well as
    references, see `dct`.
    
    Examples
    --------
    >>> from scipy.fftpack import dctn, idctn
    >>> y = np.random.randn(16, 16)
    >>> np.allclose(y, idctn(dctn(y, norm='ortho'), norm='ortho'))
    True
",function,"('(x, type=2, shape=None, axes=None, norm=None, overwrite_x=False)',)",scipy,1.1.0,scipy.fftpack.realtransforms.dctn,fftpack.realtransforms,dctn,"Python Library Documentation: function dctn in module scipy.fftpack.realtransforms

dctn(x, type=2, shape=None, axes=None, norm=None, overwrite_x=False)
    Return multidimensional Discrete Cosine Transform along the specified axes.
    
    Parameters
    ----------
    x : array_like
        The input array.
    type : {1, 2, 3}, optional
        Type of the DCT (see Notes). Default type is 2.
    shape : tuple of ints, optional
        The shape of the result.  If both `shape` and `axes` (see below) are
        None, `shape` is ``x.shape``; if `shape` is None but `axes` is
        not None, then `shape` is ``scipy.take(x.shape, axes, axis=0)``.
        If ``shape[i] > x.shape[i]``, the i-th dimension is padded with zeros.
        If ``shape[i] < x.shape[i]``, the i-th dimension is truncated to
        length ``shape[i]``.
    axes : tuple or None, optional
        Axes along which the DCT is computed; the default is over all axes.
    norm : {None, 'ortho'}, optional
        Normalization mode (see Notes). Default is None.
    overwrite_x : bool, optional
        If True, the contents of `x` can be destroyed; the default is False.
    
    Returns
    -------
    y : ndarray of real
        The transformed input array.
    
    See Also
    --------
    idctn : Inverse multidimensional DCT
    
    Notes
    -----
    For full details of the DCT types and normalization modes, as well as
    references, see `dct`.
    
    Examples
    --------
    >>> from scipy.fftpack import dctn, idctn
    >>> y = np.random.randn(16, 16)
    >>> np.allclose(y, idctn(dctn(y, norm='ortho'), norm='ortho'))
    True
",function,"('x', 'type', 'shape', 'axes', 'norm', 'overwrite_x')","(nan, 2, None, None, None, False)","(nan, 'int', 'NoneType', 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, type=2, shape=None, axes=None, norm=None, overwrite_x=False)',)"
scipy,1.1.0,scipy.fftpack.realtransforms.dst,fftpack.realtransforms,dst,"Python Library Documentation: function dst in module scipy.fftpack.realtransforms

dst(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False)
    Return the Discrete Sine Transform of arbitrary type sequence x.
    
    Parameters
    ----------
    x : array_like
        The input array.
    type : {1, 2, 3}, optional
        Type of the DST (see Notes). Default type is 2.
    n : int, optional
        Length of the transform.  If ``n < x.shape[axis]``, `x` is
        truncated.  If ``n > x.shape[axis]``, `x` is zero-padded. The
        default results in ``n = x.shape[axis]``.
    axis : int, optional
        Axis along which the dst is computed; the default is over the
        last axis (i.e., ``axis=-1``).
    norm : {None, 'ortho'}, optional
        Normalization mode (see Notes). Default is None.
    overwrite_x : bool, optional
        If True, the contents of `x` can be destroyed; the default is False.
    
    Returns
    -------
    dst : ndarray of reals
        The transformed input array.
    
    See Also
    --------
    idst : Inverse DST
    
    Notes
    -----
    For a single dimension array ``x``.
    
    There are theoretically 8 types of the DST for different combinations of
    even/odd boundary conditions and boundary off sets [1]_, only the first
    3 types are implemented in scipy.
    
    **Type I**
    
    There are several definitions of the DST-I; we use the following
    for ``norm=None``.  DST-I assumes the input is odd around n=-1 and n=N. ::
    
                 N-1
      y[k] = 2 * sum x[n]*sin(pi*(k+1)*(n+1)/(N+1))
                 n=0
    
    Only None is supported as normalization mode for DCT-I. Note also that the
    DCT-I is only supported for input size > 1
    The (unnormalized) DCT-I is its own inverse, up to a factor `2(N+1)`.
    
    **Type II**
    
    There are several definitions of the DST-II; we use the following
    for ``norm=None``.  DST-II assumes the input is odd around n=-1/2 and
    n=N-1/2; the output is odd around k=-1 and even around k=N-1 ::
    
                N-1
      y[k] = 2* sum x[n]*sin(pi*(k+1)*(n+0.5)/N), 0 <= k < N.
                n=0
    
    if ``norm='ortho'``, ``y[k]`` is multiplied by a scaling factor `f` ::
    
        f = sqrt(1/(4*N)) if k == 0
        f = sqrt(1/(2*N)) otherwise.
    
    **Type III**
    
    There are several definitions of the DST-III, we use the following
    (for ``norm=None``).  DST-III assumes the input is odd around n=-1
    and even around n=N-1 ::
    
                                 N-2
      y[k] = x[N-1]*(-1)**k + 2* sum x[n]*sin(pi*(k+0.5)*(n+1)/N), 0 <= k < N.
                                 n=0
    
    The (unnormalized) DCT-III is the inverse of the (unnormalized) DCT-II, up
    to a factor `2N`.  The orthonormalized DST-III is exactly the inverse of
    the orthonormalized DST-II.
    
    .. versionadded:: 0.11.0
    
    References
    ----------
    .. [1] Wikipedia, ""Discrete sine transform"",
           http://en.wikipedia.org/wiki/Discrete_sine_transform
",function,"('(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False)',)",scipy,1.1.0,scipy.fftpack.realtransforms.dst,fftpack.realtransforms,dst,"Python Library Documentation: function dst in module scipy.fftpack.realtransforms

dst(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False)
    Return the Discrete Sine Transform of arbitrary type sequence x.
    
    Parameters
    ----------
    x : array_like
        The input array.
    type : {1, 2, 3}, optional
        Type of the DST (see Notes). Default type is 2.
    n : int, optional
        Length of the transform.  If ``n < x.shape[axis]``, `x` is
        truncated.  If ``n > x.shape[axis]``, `x` is zero-padded. The
        default results in ``n = x.shape[axis]``.
    axis : int, optional
        Axis along which the dst is computed; the default is over the
        last axis (i.e., ``axis=-1``).
    norm : {None, 'ortho'}, optional
        Normalization mode (see Notes). Default is None.
    overwrite_x : bool, optional
        If True, the contents of `x` can be destroyed; the default is False.
    
    Returns
    -------
    dst : ndarray of reals
        The transformed input array.
    
    See Also
    --------
    idst : Inverse DST
    
    Notes
    -----
    For a single dimension array ``x``.
    
    There are theoretically 8 types of the DST for different combinations of
    even/odd boundary conditions and boundary off sets [1]_, only the first
    3 types are implemented in scipy.
    
    **Type I**
    
    There are several definitions of the DST-I; we use the following
    for ``norm=None``.  DST-I assumes the input is odd around n=-1 and n=N. ::
    
                 N-1
      y[k] = 2 * sum x[n]*sin(pi*(k+1)*(n+1)/(N+1))
                 n=0
    
    Only None is supported as normalization mode for DCT-I. Note also that the
    DCT-I is only supported for input size > 1
    The (unnormalized) DCT-I is its own inverse, up to a factor `2(N+1)`.
    
    **Type II**
    
    There are several definitions of the DST-II; we use the following
    for ``norm=None``.  DST-II assumes the input is odd around n=-1/2 and
    n=N-1/2; the output is odd around k=-1 and even around k=N-1 ::
    
                N-1
      y[k] = 2* sum x[n]*sin(pi*(k+1)*(n+0.5)/N), 0 <= k < N.
                n=0
    
    if ``norm='ortho'``, ``y[k]`` is multiplied by a scaling factor `f` ::
    
        f = sqrt(1/(4*N)) if k == 0
        f = sqrt(1/(2*N)) otherwise.
    
    **Type III**
    
    There are several definitions of the DST-III, we use the following
    (for ``norm=None``).  DST-III assumes the input is odd around n=-1
    and even around n=N-1 ::
    
                                 N-2
      y[k] = x[N-1]*(-1)**k + 2* sum x[n]*sin(pi*(k+0.5)*(n+1)/N), 0 <= k < N.
                                 n=0
    
    The (unnormalized) DCT-III is the inverse of the (unnormalized) DCT-II, up
    to a factor `2N`.  The orthonormalized DST-III is exactly the inverse of
    the orthonormalized DST-II.
    
    .. versionadded:: 0.11.0
    
    References
    ----------
    .. [1] Wikipedia, ""Discrete sine transform"",
           http://en.wikipedia.org/wiki/Discrete_sine_transform
",function,"('x', 'type', 'n', 'axis', 'norm', 'overwrite_x')","(nan, 2, None, -1, None, False)","(nan, 'int', 'NoneType', 'int', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False)',)"
scipy,1.1.0,scipy.fftpack.realtransforms.dstn,fftpack.realtransforms,dstn,"Python Library Documentation: function dstn in module scipy.fftpack.realtransforms

dstn(x, type=2, shape=None, axes=None, norm=None, overwrite_x=False)
    Return multidimensional Discrete Sine Transform along the specified axes.
    
    Parameters
    ----------
    x : array_like
        The input array.
    type : {1, 2, 3}, optional
        Type of the DCT (see Notes). Default type is 2.
    shape : tuple of ints, optional
        The shape of the result.  If both `shape` and `axes` (see below) are
        None, `shape` is ``x.shape``; if `shape` is None but `axes` is
        not None, then `shape` is ``scipy.take(x.shape, axes, axis=0)``.
        If ``shape[i] > x.shape[i]``, the i-th dimension is padded with zeros.
        If ``shape[i] < x.shape[i]``, the i-th dimension is truncated to
        length ``shape[i]``.
    axes : tuple or None, optional
        Axes along which the DCT is computed; the default is over all axes.
    norm : {None, 'ortho'}, optional
        Normalization mode (see Notes). Default is None.
    overwrite_x : bool, optional
        If True, the contents of `x` can be destroyed; the default is False.
    
    Returns
    -------
    y : ndarray of real
        The transformed input array.
    
    See Also
    --------
    idstn : Inverse multidimensional DST
    
    Notes
    -----
    For full details of the DST types and normalization modes, as well as
    references, see `dst`.
    
    Examples
    --------
    >>> from scipy.fftpack import dstn, idstn
    >>> y = np.random.randn(16, 16)
    >>> np.allclose(y, idstn(dstn(y, norm='ortho'), norm='ortho'))
    True
",function,"('(x, type=2, shape=None, axes=None, norm=None, overwrite_x=False)',)",scipy,1.1.0,scipy.fftpack.realtransforms.dstn,fftpack.realtransforms,dstn,"Python Library Documentation: function dstn in module scipy.fftpack.realtransforms

dstn(x, type=2, shape=None, axes=None, norm=None, overwrite_x=False)
    Return multidimensional Discrete Sine Transform along the specified axes.
    
    Parameters
    ----------
    x : array_like
        The input array.
    type : {1, 2, 3}, optional
        Type of the DCT (see Notes). Default type is 2.
    shape : tuple of ints, optional
        The shape of the result.  If both `shape` and `axes` (see below) are
        None, `shape` is ``x.shape``; if `shape` is None but `axes` is
        not None, then `shape` is ``scipy.take(x.shape, axes, axis=0)``.
        If ``shape[i] > x.shape[i]``, the i-th dimension is padded with zeros.
        If ``shape[i] < x.shape[i]``, the i-th dimension is truncated to
        length ``shape[i]``.
    axes : tuple or None, optional
        Axes along which the DCT is computed; the default is over all axes.
    norm : {None, 'ortho'}, optional
        Normalization mode (see Notes). Default is None.
    overwrite_x : bool, optional
        If True, the contents of `x` can be destroyed; the default is False.
    
    Returns
    -------
    y : ndarray of real
        The transformed input array.
    
    See Also
    --------
    idstn : Inverse multidimensional DST
    
    Notes
    -----
    For full details of the DST types and normalization modes, as well as
    references, see `dst`.
    
    Examples
    --------
    >>> from scipy.fftpack import dstn, idstn
    >>> y = np.random.randn(16, 16)
    >>> np.allclose(y, idstn(dstn(y, norm='ortho'), norm='ortho'))
    True
",function,"('x', 'type', 'shape', 'axes', 'norm', 'overwrite_x')","(nan, 2, None, None, None, False)","(nan, 'int', 'NoneType', 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, type=2, shape=None, axes=None, norm=None, overwrite_x=False)',)"
scipy,1.1.0,scipy.fftpack.realtransforms.idct,fftpack.realtransforms,idct,"Python Library Documentation: function idct in module scipy.fftpack.realtransforms

idct(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False)
    Return the Inverse Discrete Cosine Transform of an arbitrary type sequence.
    
    Parameters
    ----------
    x : array_like
        The input array.
    type : {1, 2, 3}, optional
        Type of the DCT (see Notes). Default type is 2.
    n : int, optional
        Length of the transform.  If ``n < x.shape[axis]``, `x` is
        truncated.  If ``n > x.shape[axis]``, `x` is zero-padded. The
        default results in ``n = x.shape[axis]``.
    axis : int, optional
        Axis along which the idct is computed; the default is over the
        last axis (i.e., ``axis=-1``).
    norm : {None, 'ortho'}, optional
        Normalization mode (see Notes). Default is None.
    overwrite_x : bool, optional
        If True, the contents of `x` can be destroyed; the default is False.
    
    Returns
    -------
    idct : ndarray of real
        The transformed input array.
    
    See Also
    --------
    dct : Forward DCT
    
    Notes
    -----
    For a single dimension array `x`, ``idct(x, norm='ortho')`` is equal to
    MATLAB ``idct(x)``.
    
    'The' IDCT is the IDCT of type 2, which is the same as DCT of type 3.
    
    IDCT of type 1 is the DCT of type 1, IDCT of type 2 is the DCT of type
    3, and IDCT of type 3 is the DCT of type 2. For the definition of these
    types, see `dct`.
    
    Examples
    --------
    The Type 1 DCT is equivalent to the DFT for real, even-symmetrical
    inputs.  The output is also real and even-symmetrical.  Half of the IFFT
    input is used to generate half of the IFFT output:
    
    >>> from scipy.fftpack import ifft, idct
    >>> ifft(np.array([ 30.,  -8.,   6.,  -2.,   6.,  -8.])).real
    array([  4.,   3.,   5.,  10.,   5.,   3.])
    >>> idct(np.array([ 30.,  -8.,   6.,  -2.]), 1) / 6
    array([  4.,   3.,   5.,  10.])
",function,"('(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False)',)",scipy,1.1.0,scipy.fftpack.realtransforms.idct,fftpack.realtransforms,idct,"Python Library Documentation: function idct in module scipy.fftpack.realtransforms

idct(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False)
    Return the Inverse Discrete Cosine Transform of an arbitrary type sequence.
    
    Parameters
    ----------
    x : array_like
        The input array.
    type : {1, 2, 3}, optional
        Type of the DCT (see Notes). Default type is 2.
    n : int, optional
        Length of the transform.  If ``n < x.shape[axis]``, `x` is
        truncated.  If ``n > x.shape[axis]``, `x` is zero-padded. The
        default results in ``n = x.shape[axis]``.
    axis : int, optional
        Axis along which the idct is computed; the default is over the
        last axis (i.e., ``axis=-1``).
    norm : {None, 'ortho'}, optional
        Normalization mode (see Notes). Default is None.
    overwrite_x : bool, optional
        If True, the contents of `x` can be destroyed; the default is False.
    
    Returns
    -------
    idct : ndarray of real
        The transformed input array.
    
    See Also
    --------
    dct : Forward DCT
    
    Notes
    -----
    For a single dimension array `x`, ``idct(x, norm='ortho')`` is equal to
    MATLAB ``idct(x)``.
    
    'The' IDCT is the IDCT of type 2, which is the same as DCT of type 3.
    
    IDCT of type 1 is the DCT of type 1, IDCT of type 2 is the DCT of type
    3, and IDCT of type 3 is the DCT of type 2. For the definition of these
    types, see `dct`.
    
    Examples
    --------
    The Type 1 DCT is equivalent to the DFT for real, even-symmetrical
    inputs.  The output is also real and even-symmetrical.  Half of the IFFT
    input is used to generate half of the IFFT output:
    
    >>> from scipy.fftpack import ifft, idct
    >>> ifft(np.array([ 30.,  -8.,   6.,  -2.,   6.,  -8.])).real
    array([  4.,   3.,   5.,  10.,   5.,   3.])
    >>> idct(np.array([ 30.,  -8.,   6.,  -2.]), 1) / 6
    array([  4.,   3.,   5.,  10.])
",function,"('x', 'type', 'n', 'axis', 'norm', 'overwrite_x')","(nan, 2, None, -1, None, False)","(nan, 'int', 'NoneType', 'int', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False)',)"
scipy,1.1.0,scipy.fftpack.realtransforms.idctn,fftpack.realtransforms,idctn,"Python Library Documentation: function idctn in module scipy.fftpack.realtransforms

idctn(x, type=2, shape=None, axes=None, norm=None, overwrite_x=False)
    Return multidimensional Discrete Cosine Transform along the specified axes.
    
    Parameters
    ----------
    x : array_like
        The input array.
    type : {1, 2, 3}, optional
        Type of the DCT (see Notes). Default type is 2.
    shape : tuple of ints, optional
        The shape of the result.  If both `shape` and `axes` (see below) are
        None, `shape` is ``x.shape``; if `shape` is None but `axes` is
        not None, then `shape` is ``scipy.take(x.shape, axes, axis=0)``.
        If ``shape[i] > x.shape[i]``, the i-th dimension is padded with zeros.
        If ``shape[i] < x.shape[i]``, the i-th dimension is truncated to
        length ``shape[i]``.
    axes : tuple or None, optional
        Axes along which the IDCT is computed; the default is over all axes.
    norm : {None, 'ortho'}, optional
        Normalization mode (see Notes). Default is None.
    overwrite_x : bool, optional
        If True, the contents of `x` can be destroyed; the default is False.
    
    Returns
    -------
    y : ndarray of real
        The transformed input array.
    
    See Also
    --------
    dctn : multidimensional DCT
    
    Notes
    -----
    For full details of the IDCT types and normalization modes, as well as
    references, see `idct`.
    
    Examples
    --------
    >>> from scipy.fftpack import dctn, idctn
    >>> y = np.random.randn(16, 16)
    >>> np.allclose(y, idctn(dctn(y, norm='ortho'), norm='ortho'))
    True
",function,"('(x, type=2, shape=None, axes=None, norm=None, overwrite_x=False)',)",scipy,1.1.0,scipy.fftpack.realtransforms.idctn,fftpack.realtransforms,idctn,"Python Library Documentation: function idctn in module scipy.fftpack.realtransforms

idctn(x, type=2, shape=None, axes=None, norm=None, overwrite_x=False)
    Return multidimensional Discrete Cosine Transform along the specified axes.
    
    Parameters
    ----------
    x : array_like
        The input array.
    type : {1, 2, 3}, optional
        Type of the DCT (see Notes). Default type is 2.
    shape : tuple of ints, optional
        The shape of the result.  If both `shape` and `axes` (see below) are
        None, `shape` is ``x.shape``; if `shape` is None but `axes` is
        not None, then `shape` is ``scipy.take(x.shape, axes, axis=0)``.
        If ``shape[i] > x.shape[i]``, the i-th dimension is padded with zeros.
        If ``shape[i] < x.shape[i]``, the i-th dimension is truncated to
        length ``shape[i]``.
    axes : tuple or None, optional
        Axes along which the IDCT is computed; the default is over all axes.
    norm : {None, 'ortho'}, optional
        Normalization mode (see Notes). Default is None.
    overwrite_x : bool, optional
        If True, the contents of `x` can be destroyed; the default is False.
    
    Returns
    -------
    y : ndarray of real
        The transformed input array.
    
    See Also
    --------
    dctn : multidimensional DCT
    
    Notes
    -----
    For full details of the IDCT types and normalization modes, as well as
    references, see `idct`.
    
    Examples
    --------
    >>> from scipy.fftpack import dctn, idctn
    >>> y = np.random.randn(16, 16)
    >>> np.allclose(y, idctn(dctn(y, norm='ortho'), norm='ortho'))
    True
",function,"('x', 'type', 'shape', 'axes', 'norm', 'overwrite_x')","(nan, 2, None, None, None, False)","(nan, 'int', 'NoneType', 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, type=2, shape=None, axes=None, norm=None, overwrite_x=False)',)"
scipy,1.1.0,scipy.fftpack.realtransforms.idst,fftpack.realtransforms,idst,"Python Library Documentation: function idst in module scipy.fftpack.realtransforms

idst(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False)
    Return the Inverse Discrete Sine Transform of an arbitrary type sequence.
    
    Parameters
    ----------
    x : array_like
        The input array.
    type : {1, 2, 3}, optional
        Type of the DST (see Notes). Default type is 2.
    n : int, optional
        Length of the transform.  If ``n < x.shape[axis]``, `x` is
        truncated.  If ``n > x.shape[axis]``, `x` is zero-padded. The
        default results in ``n = x.shape[axis]``.
    axis : int, optional
        Axis along which the idst is computed; the default is over the
        last axis (i.e., ``axis=-1``).
    norm : {None, 'ortho'}, optional
        Normalization mode (see Notes). Default is None.
    overwrite_x : bool, optional
        If True, the contents of `x` can be destroyed; the default is False.
    
    Returns
    -------
    idst : ndarray of real
        The transformed input array.
    
    See Also
    --------
    dst : Forward DST
    
    Notes
    -----
    'The' IDST is the IDST of type 2, which is the same as DST of type 3.
    
    IDST of type 1 is the DST of type 1, IDST of type 2 is the DST of type
    3, and IDST of type 3 is the DST of type 2. For the definition of these
    types, see `dst`.
    
    .. versionadded:: 0.11.0
",function,"('(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False)',)",scipy,1.1.0,scipy.fftpack.realtransforms.idst,fftpack.realtransforms,idst,"Python Library Documentation: function idst in module scipy.fftpack.realtransforms

idst(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False)
    Return the Inverse Discrete Sine Transform of an arbitrary type sequence.
    
    Parameters
    ----------
    x : array_like
        The input array.
    type : {1, 2, 3}, optional
        Type of the DST (see Notes). Default type is 2.
    n : int, optional
        Length of the transform.  If ``n < x.shape[axis]``, `x` is
        truncated.  If ``n > x.shape[axis]``, `x` is zero-padded. The
        default results in ``n = x.shape[axis]``.
    axis : int, optional
        Axis along which the idst is computed; the default is over the
        last axis (i.e., ``axis=-1``).
    norm : {None, 'ortho'}, optional
        Normalization mode (see Notes). Default is None.
    overwrite_x : bool, optional
        If True, the contents of `x` can be destroyed; the default is False.
    
    Returns
    -------
    idst : ndarray of real
        The transformed input array.
    
    See Also
    --------
    dst : Forward DST
    
    Notes
    -----
    'The' IDST is the IDST of type 2, which is the same as DST of type 3.
    
    IDST of type 1 is the DST of type 1, IDST of type 2 is the DST of type
    3, and IDST of type 3 is the DST of type 2. For the definition of these
    types, see `dst`.
    
    .. versionadded:: 0.11.0
",function,"('x', 'type', 'n', 'axis', 'norm', 'overwrite_x')","(nan, 2, None, -1, None, False)","(nan, 'int', 'NoneType', 'int', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False)',)"
scipy,1.1.0,scipy.fftpack.realtransforms.idstn,fftpack.realtransforms,idstn,"Python Library Documentation: function idstn in module scipy.fftpack.realtransforms

idstn(x, type=2, shape=None, axes=None, norm=None, overwrite_x=False)
    Return multidimensional Discrete Sine Transform along the specified axes.
    
    Parameters
    ----------
    x : array_like
        The input array.
    type : {1, 2, 3}, optional
        Type of the DCT (see Notes). Default type is 2.
    shape : tuple of ints, optional
        The shape of the result.  If both `shape` and `axes` (see below) are
        None, `shape` is ``x.shape``; if `shape` is None but `axes` is
        not None, then `shape` is ``scipy.take(x.shape, axes, axis=0)``.
        If ``shape[i] > x.shape[i]``, the i-th dimension is padded with zeros.
        If ``shape[i] < x.shape[i]``, the i-th dimension is truncated to
        length ``shape[i]``.
    axes : tuple or None, optional
        Axes along which the IDCT is computed; the default is over all axes.
    norm : {None, 'ortho'}, optional
        Normalization mode (see Notes). Default is None.
    overwrite_x : bool, optional
        If True, the contents of `x` can be destroyed; the default is False.
    
    Returns
    -------
    y : ndarray of real
        The transformed input array.
    
    See Also
    --------
    dctn : multidimensional DST
    
    Notes
    -----
    For full details of the IDST types and normalization modes, as well as
    references, see `idst`.
    
    Examples
    --------
    >>> from scipy.fftpack import dstn, idstn
    >>> y = np.random.randn(16, 16)
    >>> np.allclose(y, idstn(dstn(y, norm='ortho'), norm='ortho'))
    True
",function,"('(x, type=2, shape=None, axes=None, norm=None, overwrite_x=False)',)",scipy,1.1.0,scipy.fftpack.realtransforms.idstn,fftpack.realtransforms,idstn,"Python Library Documentation: function idstn in module scipy.fftpack.realtransforms

idstn(x, type=2, shape=None, axes=None, norm=None, overwrite_x=False)
    Return multidimensional Discrete Sine Transform along the specified axes.
    
    Parameters
    ----------
    x : array_like
        The input array.
    type : {1, 2, 3}, optional
        Type of the DCT (see Notes). Default type is 2.
    shape : tuple of ints, optional
        The shape of the result.  If both `shape` and `axes` (see below) are
        None, `shape` is ``x.shape``; if `shape` is None but `axes` is
        not None, then `shape` is ``scipy.take(x.shape, axes, axis=0)``.
        If ``shape[i] > x.shape[i]``, the i-th dimension is padded with zeros.
        If ``shape[i] < x.shape[i]``, the i-th dimension is truncated to
        length ``shape[i]``.
    axes : tuple or None, optional
        Axes along which the IDCT is computed; the default is over all axes.
    norm : {None, 'ortho'}, optional
        Normalization mode (see Notes). Default is None.
    overwrite_x : bool, optional
        If True, the contents of `x` can be destroyed; the default is False.
    
    Returns
    -------
    y : ndarray of real
        The transformed input array.
    
    See Also
    --------
    dctn : multidimensional DST
    
    Notes
    -----
    For full details of the IDST types and normalization modes, as well as
    references, see `idst`.
    
    Examples
    --------
    >>> from scipy.fftpack import dstn, idstn
    >>> y = np.random.randn(16, 16)
    >>> np.allclose(y, idstn(dstn(y, norm='ortho'), norm='ortho'))
    True
",function,"('x', 'type', 'shape', 'axes', 'norm', 'overwrite_x')","(nan, 2, None, None, None, False)","(nan, 'int', 'NoneType', 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, type=2, shape=None, axes=None, norm=None, overwrite_x=False)',)"
scipy,1.1.0,scipy.integrate._bvp.BVPResult,integrate._bvp,BVPResult,"Python Library Documentation: class BVPResult in module scipy.integrate._bvp

class BVPResult(scipy.optimize.optimize.OptimizeResult)
 |  Represents the optimization result.
 |  
 |  Attributes
 |  ----------
 |  x : ndarray
 |      The solution of the optimization.
 |  success : bool
 |      Whether or not the optimizer exited successfully.
 |  status : int
 |      Termination status of the optimizer. Its value depends on the
 |      underlying solver. Refer to `message` for details.
 |  message : str
 |      Description of the cause of the termination.
 |  fun, jac, hess: ndarray
 |      Values of objective function, its Jacobian and its Hessian (if
 |      available). The Hessians may be approximations, see the documentation
 |      of the function in question.
 |  hess_inv : object
 |      Inverse of the objective function's Hessian; may be an approximation.
 |      Not available for all solvers. The type of this attribute may be
 |      either np.ndarray or scipy.sparse.linalg.LinearOperator.
 |  nfev, njev, nhev : int
 |      Number of evaluations of the objective functions and of its
 |      Jacobian and Hessian.
 |  nit : int
 |      Number of iterations performed by the optimizer.
 |  maxcv : float
 |      The maximum constraint violation.
 |  
 |  Notes
 |  -----
 |  There may be additional attributes not listed above depending of the
 |  specific solver. Since this class is essentially a subclass of dict
 |  with attribute accessors, one can see which attributes are available
 |  using the `keys()` method.
 |  
 |  Method resolution order:
 |      BVPResult
 |      scipy.optimize.optimize.OptimizeResult
 |      builtins.dict
 |      builtins.object
 |  
 |  Methods inherited from scipy.optimize.optimize.OptimizeResult:
 |  
 |  __delattr__ = __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __dir__(self)
 |      __dir__() -> list
 |      default dir() implementation
 |  
 |  __getattr__(self, name)
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __setattr__ = __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.optimize.optimize.OptimizeResult:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.dict:
 |  
 |  __contains__(self, key, /)
 |      True if D has a key k, else False.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __sizeof__(...)
 |      D.__sizeof__() -> size of D in memory, in bytes
 |  
 |  clear(...)
 |      D.clear() -> None.  Remove all items from D.
 |  
 |  copy(...)
 |      D.copy() -> a shallow copy of D
 |  
 |  fromkeys(iterable, value=None, /) from builtins.type
 |      Returns a new dict with keys from iterable and values equal to value.
 |  
 |  get(...)
 |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
 |  
 |  items(...)
 |      D.items() -> a set-like object providing a view on D's items
 |  
 |  keys(...)
 |      D.keys() -> a set-like object providing a view on D's keys
 |  
 |  pop(...)
 |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
 |      If key is not found, d is returned if given, otherwise KeyError is raised
 |  
 |  popitem(...)
 |      D.popitem() -> (k, v), remove and return some (key, value) pair as a
 |      2-tuple; but raise KeyError if D is empty.
 |  
 |  setdefault(...)
 |      D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
 |  
 |  update(...)
 |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
 |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
 |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
 |      In either case, this is followed by: for k in F:  D[k] = F[k]
 |  
 |  values(...)
 |      D.values() -> an object providing a view on D's values
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from builtins.dict:
 |  
 |  __hash__ = None
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.integrate._bvp.BVPResult,integrate._bvp,BVPResult,"Python Library Documentation: class BVPResult in module scipy.integrate._bvp

class BVPResult(scipy.optimize.optimize.OptimizeResult)
 |  Represents the optimization result.
 |  
 |  Attributes
 |  ----------
 |  x : ndarray
 |      The solution of the optimization.
 |  success : bool
 |      Whether or not the optimizer exited successfully.
 |  status : int
 |      Termination status of the optimizer. Its value depends on the
 |      underlying solver. Refer to `message` for details.
 |  message : str
 |      Description of the cause of the termination.
 |  fun, jac, hess: ndarray
 |      Values of objective function, its Jacobian and its Hessian (if
 |      available). The Hessians may be approximations, see the documentation
 |      of the function in question.
 |  hess_inv : object
 |      Inverse of the objective function's Hessian; may be an approximation.
 |      Not available for all solvers. The type of this attribute may be
 |      either np.ndarray or scipy.sparse.linalg.LinearOperator.
 |  nfev, njev, nhev : int
 |      Number of evaluations of the objective functions and of its
 |      Jacobian and Hessian.
 |  nit : int
 |      Number of iterations performed by the optimizer.
 |  maxcv : float
 |      The maximum constraint violation.
 |  
 |  Notes
 |  -----
 |  There may be additional attributes not listed above depending of the
 |  specific solver. Since this class is essentially a subclass of dict
 |  with attribute accessors, one can see which attributes are available
 |  using the `keys()` method.
 |  
 |  Method resolution order:
 |      BVPResult
 |      scipy.optimize.optimize.OptimizeResult
 |      builtins.dict
 |      builtins.object
 |  
 |  Methods inherited from scipy.optimize.optimize.OptimizeResult:
 |  
 |  __delattr__ = __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __dir__(self)
 |      __dir__() -> list
 |      default dir() implementation
 |  
 |  __getattr__(self, name)
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __setattr__ = __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.optimize.optimize.OptimizeResult:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.dict:
 |  
 |  __contains__(self, key, /)
 |      True if D has a key k, else False.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __sizeof__(...)
 |      D.__sizeof__() -> size of D in memory, in bytes
 |  
 |  clear(...)
 |      D.clear() -> None.  Remove all items from D.
 |  
 |  copy(...)
 |      D.copy() -> a shallow copy of D
 |  
 |  fromkeys(iterable, value=None, /) from builtins.type
 |      Returns a new dict with keys from iterable and values equal to value.
 |  
 |  get(...)
 |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
 |  
 |  items(...)
 |      D.items() -> a set-like object providing a view on D's items
 |  
 |  keys(...)
 |      D.keys() -> a set-like object providing a view on D's keys
 |  
 |  pop(...)
 |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
 |      If key is not found, d is returned if given, otherwise KeyError is raised
 |  
 |  popitem(...)
 |      D.popitem() -> (k, v), remove and return some (key, value) pair as a
 |      2-tuple; but raise KeyError if D is empty.
 |  
 |  setdefault(...)
 |      D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
 |  
 |  update(...)
 |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
 |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
 |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
 |      In either case, this is followed by: for k in F:  D[k] = F[k]
 |  
 |  values(...)
 |      D.values() -> an object providing a view on D's values
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from builtins.dict:
 |  
 |  __hash__ = None
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.integrate._bvp.OptimizeResult,integrate._bvp,OptimizeResult,"Python Library Documentation: class OptimizeResult in module scipy.optimize.optimize

class OptimizeResult(builtins.dict)
 |  Represents the optimization result.
 |  
 |  Attributes
 |  ----------
 |  x : ndarray
 |      The solution of the optimization.
 |  success : bool
 |      Whether or not the optimizer exited successfully.
 |  status : int
 |      Termination status of the optimizer. Its value depends on the
 |      underlying solver. Refer to `message` for details.
 |  message : str
 |      Description of the cause of the termination.
 |  fun, jac, hess: ndarray
 |      Values of objective function, its Jacobian and its Hessian (if
 |      available). The Hessians may be approximations, see the documentation
 |      of the function in question.
 |  hess_inv : object
 |      Inverse of the objective function's Hessian; may be an approximation.
 |      Not available for all solvers. The type of this attribute may be
 |      either np.ndarray or scipy.sparse.linalg.LinearOperator.
 |  nfev, njev, nhev : int
 |      Number of evaluations of the objective functions and of its
 |      Jacobian and Hessian.
 |  nit : int
 |      Number of iterations performed by the optimizer.
 |  maxcv : float
 |      The maximum constraint violation.
 |  
 |  Notes
 |  -----
 |  There may be additional attributes not listed above depending of the
 |  specific solver. Since this class is essentially a subclass of dict
 |  with attribute accessors, one can see which attributes are available
 |  using the `keys()` method.
 |  
 |  Method resolution order:
 |      OptimizeResult
 |      builtins.dict
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __delattr__ = __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __dir__(self)
 |      __dir__() -> list
 |      default dir() implementation
 |  
 |  __getattr__(self, name)
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __setattr__ = __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.dict:
 |  
 |  __contains__(self, key, /)
 |      True if D has a key k, else False.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __sizeof__(...)
 |      D.__sizeof__() -> size of D in memory, in bytes
 |  
 |  clear(...)
 |      D.clear() -> None.  Remove all items from D.
 |  
 |  copy(...)
 |      D.copy() -> a shallow copy of D
 |  
 |  fromkeys(iterable, value=None, /) from builtins.type
 |      Returns a new dict with keys from iterable and values equal to value.
 |  
 |  get(...)
 |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
 |  
 |  items(...)
 |      D.items() -> a set-like object providing a view on D's items
 |  
 |  keys(...)
 |      D.keys() -> a set-like object providing a view on D's keys
 |  
 |  pop(...)
 |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
 |      If key is not found, d is returned if given, otherwise KeyError is raised
 |  
 |  popitem(...)
 |      D.popitem() -> (k, v), remove and return some (key, value) pair as a
 |      2-tuple; but raise KeyError if D is empty.
 |  
 |  setdefault(...)
 |      D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
 |  
 |  update(...)
 |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
 |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
 |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
 |      In either case, this is followed by: for k in F:  D[k] = F[k]
 |  
 |  values(...)
 |      D.values() -> an object providing a view on D's values
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from builtins.dict:
 |  
 |  __hash__ = None
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.integrate._bvp.OptimizeResult,integrate._bvp,OptimizeResult,"Python Library Documentation: class OptimizeResult in module scipy.optimize.optimize

class OptimizeResult(builtins.dict)
 |  Represents the optimization result.
 |  
 |  Attributes
 |  ----------
 |  x : ndarray
 |      The solution of the optimization.
 |  success : bool
 |      Whether or not the optimizer exited successfully.
 |  status : int
 |      Termination status of the optimizer. Its value depends on the
 |      underlying solver. Refer to `message` for details.
 |  message : str
 |      Description of the cause of the termination.
 |  fun, jac, hess: ndarray
 |      Values of objective function, its Jacobian and its Hessian (if
 |      available). The Hessians may be approximations, see the documentation
 |      of the function in question.
 |  hess_inv : object
 |      Inverse of the objective function's Hessian; may be an approximation.
 |      Not available for all solvers. The type of this attribute may be
 |      either np.ndarray or scipy.sparse.linalg.LinearOperator.
 |  nfev, njev, nhev : int
 |      Number of evaluations of the objective functions and of its
 |      Jacobian and Hessian.
 |  nit : int
 |      Number of iterations performed by the optimizer.
 |  maxcv : float
 |      The maximum constraint violation.
 |  
 |  Notes
 |  -----
 |  There may be additional attributes not listed above depending of the
 |  specific solver. Since this class is essentially a subclass of dict
 |  with attribute accessors, one can see which attributes are available
 |  using the `keys()` method.
 |  
 |  Method resolution order:
 |      OptimizeResult
 |      builtins.dict
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __delattr__ = __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __dir__(self)
 |      __dir__() -> list
 |      default dir() implementation
 |  
 |  __getattr__(self, name)
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __setattr__ = __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.dict:
 |  
 |  __contains__(self, key, /)
 |      True if D has a key k, else False.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __sizeof__(...)
 |      D.__sizeof__() -> size of D in memory, in bytes
 |  
 |  clear(...)
 |      D.clear() -> None.  Remove all items from D.
 |  
 |  copy(...)
 |      D.copy() -> a shallow copy of D
 |  
 |  fromkeys(iterable, value=None, /) from builtins.type
 |      Returns a new dict with keys from iterable and values equal to value.
 |  
 |  get(...)
 |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
 |  
 |  items(...)
 |      D.items() -> a set-like object providing a view on D's items
 |  
 |  keys(...)
 |      D.keys() -> a set-like object providing a view on D's keys
 |  
 |  pop(...)
 |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
 |      If key is not found, d is returned if given, otherwise KeyError is raised
 |  
 |  popitem(...)
 |      D.popitem() -> (k, v), remove and return some (key, value) pair as a
 |      2-tuple; but raise KeyError if D is empty.
 |  
 |  setdefault(...)
 |      D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
 |  
 |  update(...)
 |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
 |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
 |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
 |      In either case, this is followed by: for k in F:  D[k] = F[k]
 |  
 |  values(...)
 |      D.values() -> an object providing a view on D's values
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from builtins.dict:
 |  
 |  __hash__ = None
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.integrate._bvp.collocation_fun,integrate._bvp,collocation_fun,"Python Library Documentation: function collocation_fun in module scipy.integrate._bvp

collocation_fun(fun, y, p, x, h)
    Evaluate collocation residuals.
    
    This function lies in the core of the method. The solution is sought
    as a cubic C1 continuous spline with derivatives matching the ODE rhs
    at given nodes `x`. Collocation conditions are formed from the equality
    of the spline derivatives and rhs of the ODE system in the middle points
    between nodes.
    
    Such method is classified to Lobbato IIIA family in ODE literature.
    Refer to [1]_ for the formula and some discussion.
    
    Returns
    -------
    col_res : ndarray, shape (n, m - 1)
        Collocation residuals at the middle points of the mesh intervals.
    y_middle : ndarray, shape (n, m - 1)
        Values of the cubic spline evaluated at the middle points of the mesh
        intervals.
    f : ndarray, shape (n, m)
        RHS of the ODE system evaluated at the mesh nodes.
    f_middle : ndarray, shape (n, m - 1)
        RHS of the ODE system evaluated at the middle points of the mesh
        intervals (and using `y_middle`).
    
    References
    ----------
    .. [1] J. Kierzenka, L. F. Shampine, ""A BVP Solver Based on Residual
           Control and the Maltab PSE"", ACM Trans. Math. Softw., Vol. 27,
           Number 3, pp. 299-316, 2001.
",function,"('(fun, y, p, x, h)',)",scipy,1.1.0,scipy.integrate._bvp.collocation_fun,integrate._bvp,collocation_fun,"Python Library Documentation: function collocation_fun in module scipy.integrate._bvp

collocation_fun(fun, y, p, x, h)
    Evaluate collocation residuals.
    
    This function lies in the core of the method. The solution is sought
    as a cubic C1 continuous spline with derivatives matching the ODE rhs
    at given nodes `x`. Collocation conditions are formed from the equality
    of the spline derivatives and rhs of the ODE system in the middle points
    between nodes.
    
    Such method is classified to Lobbato IIIA family in ODE literature.
    Refer to [1]_ for the formula and some discussion.
    
    Returns
    -------
    col_res : ndarray, shape (n, m - 1)
        Collocation residuals at the middle points of the mesh intervals.
    y_middle : ndarray, shape (n, m - 1)
        Values of the cubic spline evaluated at the middle points of the mesh
        intervals.
    f : ndarray, shape (n, m)
        RHS of the ODE system evaluated at the mesh nodes.
    f_middle : ndarray, shape (n, m - 1)
        RHS of the ODE system evaluated at the middle points of the mesh
        intervals (and using `y_middle`).
    
    References
    ----------
    .. [1] J. Kierzenka, L. F. Shampine, ""A BVP Solver Based on Residual
           Control and the Maltab PSE"", ACM Trans. Math. Softw., Vol. 27,
           Number 3, pp. 299-316, 2001.
",function,"('fun', 'y', 'p', 'x', 'h')","(nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(fun, y, p, x, h)',)"
scipy,1.1.0,scipy.integrate._bvp.compute_jac_indices,integrate._bvp,compute_jac_indices,"Python Library Documentation: function compute_jac_indices in module scipy.integrate._bvp

compute_jac_indices(n, m, k)
    Compute indices for the collocation system Jacobian construction.
    
    See `construct_global_jac` for the explanation.
",function,"('(n, m, k)',)",scipy,1.1.0,scipy.integrate._bvp.compute_jac_indices,integrate._bvp,compute_jac_indices,"Python Library Documentation: function compute_jac_indices in module scipy.integrate._bvp

compute_jac_indices(n, m, k)
    Compute indices for the collocation system Jacobian construction.
    
    See `construct_global_jac` for the explanation.
",function,"('n', 'm', 'k')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(n, m, k)',)"
scipy,1.1.0,scipy.integrate._bvp.construct_global_jac,integrate._bvp,construct_global_jac,"Python Library Documentation: function construct_global_jac in module scipy.integrate._bvp

construct_global_jac(n, m, k, i_jac, j_jac, h, df_dy, df_dy_middle, df_dp, df_dp_middle, dbc_dya, dbc_dyb, dbc_dp)
    Construct the Jacobian of the collocation system.
    
    There are n * m + k functions: m - 1 collocations residuals, each
    containing n components, followed by n + k boundary condition residuals.
    
    There are n * m + k variables: m vectors of y, each containing n
    components, followed by k values of vector p.
    
    For example, let m = 4, n = 2 and k = 1, then the Jacobian will have
    the following sparsity structure:
    
        1 1 2 2 0 0 0 0  5
        1 1 2 2 0 0 0 0  5
        0 0 1 1 2 2 0 0  5
        0 0 1 1 2 2 0 0  5
        0 0 0 0 1 1 2 2  5
        0 0 0 0 1 1 2 2  5
    
        3 3 0 0 0 0 4 4  6
        3 3 0 0 0 0 4 4  6
        3 3 0 0 0 0 4 4  6
    
    Zeros denote identically zero values, other values denote different kinds
    of blocks in the matrix (see below). The blank row indicates the separation
    of collocation residuals from boundary conditions. And the blank column
    indicates the separation of y values from p values.
    
    Refer to [1]_  (p. 306) for the formula of n x n blocks for derivatives
    of collocation residuals with respect to y.
    
    Parameters
    ----------
    n : int
        Number of equations in the ODE system.
    m : int
        Number of nodes in the mesh.
    k : int
        Number of the unknown parameters.
    i_jac, j_jac : ndarray
        Row and column indices returned by `compute_jac_indices`. They
        represent different blocks in the Jacobian matrix in the following
        order (see the scheme above):
    
            * 1: m - 1 diagonal n x n blocks for the collocation residuals.
            * 2: m - 1 off-diagonal n x n blocks for the collocation residuals.
            * 3 : (n + k) x n block for the dependency of the boundary
              conditions on ya.
            * 4: (n + k) x n block for the dependency of the boundary
              conditions on yb.
            * 5: (m - 1) * n x k block for the dependency of the collocation
              residuals on p.
            * 6: (n + k) x k block for the dependency of the boundary
              conditions on p.
    
    df_dy : ndarray, shape (n, n, m)
        Jacobian of f with respect to y computed at the mesh nodes.
    df_dy_middle : ndarray, shape (n, n, m - 1)
        Jacobian of f with respect to y computed at the middle between the
        mesh nodes.
    df_dp : ndarray with shape (n, k, m) or None
        Jacobian of f with respect to p computed at the mesh nodes.
    df_dp_middle: ndarray with shape (n, k, m - 1) or None
        Jacobian of f with respect to p computed at the middle between the
        mesh nodes.
    dbc_dya, dbc_dyb : ndarray, shape (n, n)
        Jacobian of bc with respect to ya and yb.
    dbc_dp: ndarray with shape (n, k) or None
        Jacobian of bc with respect to p.
    
    Returns
    -------
    J : csc_matrix, shape (n * m + k, n * m + k)
        Jacobian of the collocation system in a sparse form.
    
    References
    ----------
    .. [1] J. Kierzenka, L. F. Shampine, ""A BVP Solver Based on Residual
       Control and the Maltab PSE"", ACM Trans. Math. Softw., Vol. 27,
       Number 3, pp. 299-316, 2001.
",function,"('(n, m, k, i_jac, j_jac, h, df_dy, df_dy_middle, df_dp, df_dp_middle, dbc_dya, dbc_dyb, dbc_dp)',)",scipy,1.1.0,scipy.integrate._bvp.construct_global_jac,integrate._bvp,construct_global_jac,"Python Library Documentation: function construct_global_jac in module scipy.integrate._bvp

construct_global_jac(n, m, k, i_jac, j_jac, h, df_dy, df_dy_middle, df_dp, df_dp_middle, dbc_dya, dbc_dyb, dbc_dp)
    Construct the Jacobian of the collocation system.
    
    There are n * m + k functions: m - 1 collocations residuals, each
    containing n components, followed by n + k boundary condition residuals.
    
    There are n * m + k variables: m vectors of y, each containing n
    components, followed by k values of vector p.
    
    For example, let m = 4, n = 2 and k = 1, then the Jacobian will have
    the following sparsity structure:
    
        1 1 2 2 0 0 0 0  5
        1 1 2 2 0 0 0 0  5
        0 0 1 1 2 2 0 0  5
        0 0 1 1 2 2 0 0  5
        0 0 0 0 1 1 2 2  5
        0 0 0 0 1 1 2 2  5
    
        3 3 0 0 0 0 4 4  6
        3 3 0 0 0 0 4 4  6
        3 3 0 0 0 0 4 4  6
    
    Zeros denote identically zero values, other values denote different kinds
    of blocks in the matrix (see below). The blank row indicates the separation
    of collocation residuals from boundary conditions. And the blank column
    indicates the separation of y values from p values.
    
    Refer to [1]_  (p. 306) for the formula of n x n blocks for derivatives
    of collocation residuals with respect to y.
    
    Parameters
    ----------
    n : int
        Number of equations in the ODE system.
    m : int
        Number of nodes in the mesh.
    k : int
        Number of the unknown parameters.
    i_jac, j_jac : ndarray
        Row and column indices returned by `compute_jac_indices`. They
        represent different blocks in the Jacobian matrix in the following
        order (see the scheme above):
    
            * 1: m - 1 diagonal n x n blocks for the collocation residuals.
            * 2: m - 1 off-diagonal n x n blocks for the collocation residuals.
            * 3 : (n + k) x n block for the dependency of the boundary
              conditions on ya.
            * 4: (n + k) x n block for the dependency of the boundary
              conditions on yb.
            * 5: (m - 1) * n x k block for the dependency of the collocation
              residuals on p.
            * 6: (n + k) x k block for the dependency of the boundary
              conditions on p.
    
    df_dy : ndarray, shape (n, n, m)
        Jacobian of f with respect to y computed at the mesh nodes.
    df_dy_middle : ndarray, shape (n, n, m - 1)
        Jacobian of f with respect to y computed at the middle between the
        mesh nodes.
    df_dp : ndarray with shape (n, k, m) or None
        Jacobian of f with respect to p computed at the mesh nodes.
    df_dp_middle: ndarray with shape (n, k, m - 1) or None
        Jacobian of f with respect to p computed at the middle between the
        mesh nodes.
    dbc_dya, dbc_dyb : ndarray, shape (n, n)
        Jacobian of bc with respect to ya and yb.
    dbc_dp: ndarray with shape (n, k) or None
        Jacobian of bc with respect to p.
    
    Returns
    -------
    J : csc_matrix, shape (n * m + k, n * m + k)
        Jacobian of the collocation system in a sparse form.
    
    References
    ----------
    .. [1] J. Kierzenka, L. F. Shampine, ""A BVP Solver Based on Residual
       Control and the Maltab PSE"", ACM Trans. Math. Softw., Vol. 27,
       Number 3, pp. 299-316, 2001.
",function,"('n', 'm', 'k', 'i_jac', 'j_jac', 'h', 'df_dy', 'df_dy_middle', 'df_dp', 'df_dp_middle', 'dbc_dya', 'dbc_dyb', 'dbc_dp')","(nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(n, m, k, i_jac, j_jac, h, df_dy, df_dy_middle, df_dp, df_dp_middle, dbc_dya, dbc_dyb, dbc_dp)',)"
scipy,1.1.0,scipy.integrate._bvp.coo_matrix,integrate._bvp,coo_matrix,"Python Library Documentation: class coo_matrix in module scipy.sparse.coo

class coo_matrix(scipy.sparse.data._data_matrix, scipy.sparse.data._minmax_mixin)
 |  A sparse matrix in COOrdinate format.
 |  
 |  Also known as the 'ijv' or 'triplet' format.
 |  
 |  This can be instantiated in several ways:
 |      coo_matrix(D)
 |          with a dense matrix D
 |  
 |      coo_matrix(S)
 |          with another sparse matrix S (equivalent to S.tocoo())
 |  
 |      coo_matrix((M, N), [dtype])
 |          to construct an empty matrix with shape (M, N)
 |          dtype is optional, defaulting to dtype='d'.
 |  
 |      coo_matrix((data, (i, j)), [shape=(M, N)])
 |          to construct from three arrays:
 |              1. data[:]   the entries of the matrix, in any order
 |              2. i[:]      the row indices of the matrix entries
 |              3. j[:]      the column indices of the matrix entries
 |  
 |          Where ``A[i[k], j[k]] = data[k]``.  When shape is not
 |          specified, it is inferred from the index arrays
 |  
 |  Attributes
 |  ----------
 |  dtype : dtype
 |      Data type of the matrix
 |  shape : 2-tuple
 |      Shape of the matrix
 |  ndim : int
 |      Number of dimensions (this is always 2)
 |  nnz
 |      Number of nonzero elements
 |  data
 |      COO format data array of the matrix
 |  row
 |      COO format row index array of the matrix
 |  col
 |      COO format column index array of the matrix
 |  
 |  Notes
 |  -----
 |  
 |  Sparse matrices can be used in arithmetic operations: they support
 |  addition, subtraction, multiplication, division, and matrix power.
 |  
 |  Advantages of the COO format
 |      - facilitates fast conversion among sparse formats
 |      - permits duplicate entries (see example)
 |      - very fast conversion to and from CSR/CSC formats
 |  
 |  Disadvantages of the COO format
 |      - does not directly support:
 |          + arithmetic operations
 |          + slicing
 |  
 |  Intended Usage
 |      - COO is a fast format for constructing sparse matrices
 |      - Once a matrix has been constructed, convert to CSR or
 |        CSC format for fast arithmetic and matrix vector operations
 |      - By default when converting to CSR or CSC format, duplicate (i,j)
 |        entries will be summed together.  This facilitates efficient
 |        construction of finite element matrices and the like. (see example)
 |  
 |  Examples
 |  --------
 |  
 |  >>> # Constructing an empty matrix
 |  >>> from scipy.sparse import coo_matrix
 |  >>> coo_matrix((3, 4), dtype=np.int8).toarray()
 |  array([[0, 0, 0, 0],
 |         [0, 0, 0, 0],
 |         [0, 0, 0, 0]], dtype=int8)
 |  
 |  >>> # Constructing a matrix using ijv format
 |  >>> row  = np.array([0, 3, 1, 0])
 |  >>> col  = np.array([0, 3, 1, 2])
 |  >>> data = np.array([4, 5, 7, 9])
 |  >>> coo_matrix((data, (row, col)), shape=(4, 4)).toarray()
 |  array([[4, 0, 9, 0],
 |         [0, 7, 0, 0],
 |         [0, 0, 0, 0],
 |         [0, 0, 0, 5]])
 |  
 |  >>> # Constructing a matrix with duplicate indices
 |  >>> row  = np.array([0, 0, 1, 3, 1, 0, 0])
 |  >>> col  = np.array([0, 2, 1, 3, 1, 0, 0])
 |  >>> data = np.array([1, 1, 1, 1, 1, 1, 1])
 |  >>> coo = coo_matrix((data, (row, col)), shape=(4, 4))
 |  >>> # Duplicate indices are maintained until implicitly or explicitly summed
 |  >>> np.max(coo.data)
 |  1
 |  >>> coo.toarray()
 |  array([[3, 0, 1, 0],
 |         [0, 2, 0, 0],
 |         [0, 0, 0, 0],
 |         [0, 0, 0, 1]])
 |  
 |  Method resolution order:
 |      coo_matrix
 |      scipy.sparse.data._data_matrix
 |      scipy.sparse.base.spmatrix
 |      scipy.sparse.data._minmax_mixin
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, arg1, shape=None, dtype=None, copy=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  diagonal(self, k=0)
 |      Returns the k-th diagonal of the matrix.
 |      
 |      Parameters
 |      ----------
 |      k : int, optional
 |          Which diagonal to set, corresponding to elements a[i, i+k].
 |          Default: 0 (the main diagonal).
 |      
 |          .. versionadded:: 1.0
 |      
 |      See also
 |      --------
 |      numpy.diagonal : Equivalent numpy function.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> A.diagonal()
 |      array([1, 0, 5])
 |      >>> A.diagonal(k=1)
 |      array([2, 3])
 |  
 |  eliminate_zeros(self)
 |      Remove zero entries from the matrix
 |      
 |      This is an *in place* operation
 |  
 |  getnnz(self, axis=None)
 |      Number of stored values, including explicit zeros.
 |      
 |      Parameters
 |      ----------
 |      axis : None, 0, or 1
 |          Select between the number of values across the whole matrix, in
 |          each column, or in each row.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  reshape(self, *args, **kwargs)
 |      reshape(self, shape, order='C', copy=False)
 |      
 |      Gives a new shape to a sparse matrix without changing its data.
 |      
 |      Parameters
 |      ----------
 |      shape : length-2 tuple of ints
 |          The new shape should be compatible with the original shape.
 |      order : {'C', 'F'}, optional
 |          Read the elements using this index order. 'C' means to read and
 |          write the elements using C-like index order; e.g. read entire first
 |          row, then second row, etc. 'F' means to read and write the elements
 |          using Fortran-like index order; e.g. read entire first column, then
 |          second column, etc.
 |      copy : bool, optional
 |          Indicates whether or not attributes of self should be copied
 |          whenever possible. The degree to which attributes are copied varies
 |          depending on the type of sparse matrix being used.
 |      
 |      Returns
 |      -------
 |      reshaped_matrix : sparse matrix
 |          A sparse matrix with the given `shape`, not necessarily of the same
 |          format as the current object.
 |      
 |      See Also
 |      --------
 |      np.matrix.reshape : NumPy's implementation of 'reshape' for matrices
 |  
 |  resize(self, *shape)
 |      Resize the matrix in-place to dimensions given by ``shape``
 |      
 |      Any elements that lie within the new shape will remain at the same
 |      indices, while non-zero elements lying outside the new shape are
 |      removed.
 |      
 |      Parameters
 |      ----------
 |      shape : (int, int)
 |          number of rows and columns in the new matrix
 |      
 |      Notes
 |      -----
 |      The semantics are not identical to `numpy.ndarray.resize` or
 |      `numpy.resize`.  Here, the same data will be maintained at each index
 |      before and after reshape, if that index is within the new bounds.  In
 |      numpy, resizing maintains contiguity of the array, moving elements
 |      around in the logical matrix but not within a flattened representation.
 |      
 |      We give no guarantees about whether the underlying data attributes
 |      (arrays, etc.) will be modified in place or replaced with new objects.
 |  
 |  sum_duplicates(self)
 |      Eliminate duplicate matrix entries by adding them together
 |      
 |      This is an *in place* operation
 |  
 |  toarray(self, order=None, out=None)
 |      See the docstring for `spmatrix.toarray`.
 |  
 |  tocoo(self, copy=False)
 |      Convert this matrix to COOrdinate format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant coo_matrix.
 |  
 |  tocsc(self, copy=False)
 |      Convert this matrix to Compressed Sparse Column format
 |      
 |      Duplicate entries will be summed together.
 |      
 |      Examples
 |      --------
 |      >>> from numpy import array
 |      >>> from scipy.sparse import coo_matrix
 |      >>> row  = array([0, 0, 1, 3, 1, 0, 0])
 |      >>> col  = array([0, 2, 1, 3, 1, 0, 0])
 |      >>> data = array([1, 1, 1, 1, 1, 1, 1])
 |      >>> A = coo_matrix((data, (row, col)), shape=(4, 4)).tocsc()
 |      >>> A.toarray()
 |      array([[3, 0, 1, 0],
 |             [0, 2, 0, 0],
 |             [0, 0, 0, 0],
 |             [0, 0, 0, 1]])
 |  
 |  tocsr(self, copy=False)
 |      Convert this matrix to Compressed Sparse Row format
 |      
 |      Duplicate entries will be summed together.
 |      
 |      Examples
 |      --------
 |      >>> from numpy import array
 |      >>> from scipy.sparse import coo_matrix
 |      >>> row  = array([0, 0, 1, 3, 1, 0, 0])
 |      >>> col  = array([0, 2, 1, 3, 1, 0, 0])
 |      >>> data = array([1, 1, 1, 1, 1, 1, 1])
 |      >>> A = coo_matrix((data, (row, col)), shape=(4, 4)).tocsr()
 |      >>> A.toarray()
 |      array([[3, 0, 1, 0],
 |             [0, 2, 0, 0],
 |             [0, 0, 0, 0],
 |             [0, 0, 0, 1]])
 |  
 |  todia(self, copy=False)
 |      Convert this matrix to sparse DIAgonal format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dia_matrix.
 |  
 |  todok(self, copy=False)
 |      Convert this matrix to Dictionary Of Keys format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dok_matrix.
 |  
 |  transpose(self, axes=None, copy=False)
 |      Reverses the dimensions of the sparse matrix.
 |      
 |      Parameters
 |      ----------
 |      axes : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value.
 |      copy : bool, optional
 |          Indicates whether or not attributes of `self` should be
 |          copied whenever possible. The degree to which attributes
 |          are copied varies depending on the type of sparse matrix
 |          being used.
 |      
 |      Returns
 |      -------
 |      p : `self` with the dimensions reversed.
 |      
 |      See Also
 |      --------
 |      np.matrix.transpose : NumPy's implementation of 'transpose'
 |                            for matrices
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  format = 'coo'
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._data_matrix:
 |  
 |  __abs__(self)
 |  
 |  __imul__(self, other)
 |  
 |  __itruediv__(self, other)
 |  
 |  __neg__(self)
 |  
 |  arcsin(self)
 |      Element-wise arcsin.
 |      
 |      See numpy.arcsin for more information.
 |  
 |  arcsinh(self)
 |      Element-wise arcsinh.
 |      
 |      See numpy.arcsinh for more information.
 |  
 |  arctan(self)
 |      Element-wise arctan.
 |      
 |      See numpy.arctan for more information.
 |  
 |  arctanh(self)
 |      Element-wise arctanh.
 |      
 |      See numpy.arctanh for more information.
 |  
 |  astype(self, dtype, casting='unsafe', copy=True)
 |      Cast the matrix elements to a specified type.
 |      
 |      Parameters
 |      ----------
 |      dtype : string or numpy dtype
 |          Typecode or data-type to which to cast the data.
 |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
 |          Controls what kind of data casting may occur.
 |          Defaults to 'unsafe' for backwards compatibility.
 |          'no' means the data types should not be cast at all.
 |          'equiv' means only byte-order changes are allowed.
 |          'safe' means only casts which can preserve values are allowed.
 |          'same_kind' means only safe casts or casts within a kind,
 |          like float64 to float32, are allowed.
 |          'unsafe' means any data conversions may be done.
 |      copy : bool, optional
 |          If `copy` is `False`, the result might share some memory with this
 |          matrix. If `copy` is `True`, it is guaranteed that the result and
 |          this matrix do not share any memory.
 |  
 |  ceil(self)
 |      Element-wise ceil.
 |      
 |      See numpy.ceil for more information.
 |  
 |  conj(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  copy(self)
 |      Returns a copy of this matrix.
 |      
 |      No data/indices will be shared between the returned value and current
 |      matrix.
 |  
 |  count_nonzero(self)
 |      Number of non-zero entries, equivalent to
 |      
 |      np.count_nonzero(a.toarray())
 |      
 |      Unlike getnnz() and the nnz property, which return the number of stored
 |      entries (the length of the data attribute), this method counts the
 |      actual number of non-zero entries in data.
 |  
 |  deg2rad(self)
 |      Element-wise deg2rad.
 |      
 |      See numpy.deg2rad for more information.
 |  
 |  expm1(self)
 |      Element-wise expm1.
 |      
 |      See numpy.expm1 for more information.
 |  
 |  floor(self)
 |      Element-wise floor.
 |      
 |      See numpy.floor for more information.
 |  
 |  log1p(self)
 |      Element-wise log1p.
 |      
 |      See numpy.log1p for more information.
 |  
 |  power(self, n, dtype=None)
 |      This function performs element-wise power.
 |      
 |      Parameters
 |      ----------
 |      n : n is a scalar
 |      
 |      dtype : If dtype is not specified, the current dtype will be preserved.
 |  
 |  rad2deg(self)
 |      Element-wise rad2deg.
 |      
 |      See numpy.rad2deg for more information.
 |  
 |  rint(self)
 |      Element-wise rint.
 |      
 |      See numpy.rint for more information.
 |  
 |  sign(self)
 |      Element-wise sign.
 |      
 |      See numpy.sign for more information.
 |  
 |  sin(self)
 |      Element-wise sin.
 |      
 |      See numpy.sin for more information.
 |  
 |  sinh(self)
 |      Element-wise sinh.
 |      
 |      See numpy.sinh for more information.
 |  
 |  sqrt(self)
 |      Element-wise sqrt.
 |      
 |      See numpy.sqrt for more information.
 |  
 |  tan(self)
 |      Element-wise tan.
 |      
 |      See numpy.tan for more information.
 |  
 |  tanh(self)
 |      Element-wise tanh.
 |      
 |      See numpy.tanh for more information.
 |  
 |  trunc(self)
 |      Element-wise trunc.
 |      
 |      See numpy.trunc for more information.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.data._data_matrix:
 |  
 |  dtype
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.base.spmatrix:
 |  
 |  __add__(self, other)
 |  
 |  __bool__(self)
 |  
 |  __div__(self, other)
 |  
 |  __eq__(self, other)
 |      Return self==value.
 |  
 |  __ge__(self, other)
 |      Return self>=value.
 |  
 |  __getattr__(self, attr)
 |  
 |  __gt__(self, other)
 |      Return self>value.
 |  
 |  __iadd__(self, other)
 |  
 |  __idiv__(self, other)
 |  
 |  __isub__(self, other)
 |  
 |  __iter__(self)
 |  
 |  __le__(self, other)
 |      Return self<=value.
 |  
 |  __len__(self)
 |      # What should len(sparse) return? For consistency with dense matrices,
 |      # perhaps it should be the number of rows?  But for some uses the number of
 |      # non-zeros is more important.  For now, raise an exception!
 |  
 |  __lt__(self, other)
 |      Return self<value.
 |  
 |  __matmul__(self, other)
 |  
 |  __mul__(self, other)
 |      interpret other and call one of the following
 |      
 |      self._mul_scalar()
 |      self._mul_vector()
 |      self._mul_multivector()
 |      self._mul_sparse_matrix()
 |  
 |  __ne__(self, other)
 |      Return self!=value.
 |  
 |  __nonzero__ = __bool__(self)
 |  
 |  __pow__(self, other)
 |  
 |  __radd__(self, other)
 |  
 |  __rdiv__(self, other)
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __rmatmul__(self, other)
 |  
 |  __rmul__(self, other)
 |  
 |  __rsub__(self, other)
 |  
 |  __rtruediv__(self, other)
 |  
 |  __str__(self)
 |      Return str(self).
 |  
 |  __sub__(self, other)
 |  
 |  __truediv__(self, other)
 |  
 |  asformat(self, format, copy=False)
 |      Return this matrix in the passed sparse format.
 |      
 |      Parameters
 |      ----------
 |      format : {str, None}
 |          The desired sparse matrix format (""csr"", ""csc"", ""lil"", ""dok"", ...)
 |          or None for no conversion.
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : This matrix in the passed sparse format.
 |  
 |  asfptype(self)
 |      Upcast matrix to a floating point format (if necessary)
 |  
 |  conjugate(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  dot(self, other)
 |      Ordinary dot product
 |      
 |      Examples
 |      --------
 |      >>> import numpy as np
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> v = np.array([1, 0, -1])
 |      >>> A.dot(v)
 |      array([ 1, -3, -1], dtype=int64)
 |  
 |  getH(self)
 |      Return the Hermitian transpose of this matrix.
 |      
 |      See Also
 |      --------
 |      np.matrix.getH : NumPy's implementation of `getH` for matrices
 |  
 |  get_shape(self)
 |      Get shape of a matrix.
 |  
 |  getcol(self, j)
 |      Returns a copy of column j of the matrix, as an (m x 1) sparse
 |      matrix (column vector).
 |  
 |  getformat(self)
 |      Format of a matrix representation as a string.
 |  
 |  getmaxprint(self)
 |      Maximum number of elements to display when printed.
 |  
 |  getrow(self, i)
 |      Returns a copy of row i of the matrix, as a (1 x n) sparse
 |      matrix (row vector).
 |  
 |  maximum(self, other)
 |      Element-wise maximum between this and another matrix.
 |  
 |  mean(self, axis=None, dtype=None, out=None)
 |      Compute the arithmetic mean along the specified axis.
 |      
 |      Returns the average of the matrix elements. The average is taken
 |      over all elements in the matrix by default, otherwise over the
 |      specified axis. `float64` intermediate and return values are used
 |      for integer inputs.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the mean is computed. The default is to compute
 |          the mean of all elements in the matrix (i.e. `axis` = `None`).
 |      dtype : data-type, optional
 |          Type to use in computing the mean. For integer inputs, the default
 |          is `float64`; for floating point inputs, it is the same as the
 |          input dtype.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      m : np.matrix
 |      
 |      See Also
 |      --------
 |      np.matrix.mean : NumPy's implementation of 'mean' for matrices
 |  
 |  minimum(self, other)
 |      Element-wise minimum between this and another matrix.
 |  
 |  multiply(self, other)
 |      Point-wise multiplication by another matrix
 |  
 |  nonzero(self)
 |      nonzero indices
 |      
 |      Returns a tuple of arrays (row,col) containing the indices
 |      of the non-zero elements of the matrix.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1,2,0],[0,0,3],[4,0,5]])
 |      >>> A.nonzero()
 |      (array([0, 0, 1, 2, 2]), array([0, 1, 2, 0, 2]))
 |  
 |  set_shape(self, shape)
 |      See `reshape`.
 |  
 |  setdiag(self, values, k=0)
 |      Set diagonal or off-diagonal elements of the array.
 |      
 |      Parameters
 |      ----------
 |      values : array_like
 |          New values of the diagonal elements.
 |      
 |          Values may have any length.  If the diagonal is longer than values,
 |          then the remaining diagonal entries will not be set.  If values if
 |          longer than the diagonal, then the remaining values are ignored.
 |      
 |          If a scalar value is given, all of the diagonal is set to it.
 |      
 |      k : int, optional
 |          Which off-diagonal to set, corresponding to elements a[i,i+k].
 |          Default: 0 (the main diagonal).
 |  
 |  sum(self, axis=None, dtype=None, out=None)
 |      Sum the matrix elements over a given axis.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the sum of all the matrix elements, returning a scalar
 |          (i.e. `axis` = `None`).
 |      dtype : dtype, optional
 |          The type of the returned matrix and of the accumulator in which
 |          the elements are summed.  The dtype of `a` is used by default
 |          unless `a` has an integer dtype of less precision than the default
 |          platform integer.  In that case, if `a` is signed then the platform
 |          integer is used while if `a` is unsigned then an unsigned integer
 |          of the same precision as the platform integer is used.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      sum_along_axis : np.matrix
 |          A matrix with the same shape as `self`, with the specified
 |          axis removed.
 |      
 |      See Also
 |      --------
 |      np.matrix.sum : NumPy's implementation of 'sum' for matrices
 |  
 |  tobsr(self, blocksize=None, copy=False)
 |      Convert this matrix to Block Sparse Row format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant bsr_matrix.
 |      
 |      When blocksize=(R, C) is provided, it will be used for construction of
 |      the bsr_matrix.
 |  
 |  todense(self, order=None, out=None)
 |      Return a dense matrix representation of this matrix.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F'}, optional
 |          Whether to store multi-dimensional data in C (row-major)
 |          or Fortran (column-major) order in memory. The default
 |          is 'None', indicating the NumPy default of C-ordered.
 |          Cannot be specified in conjunction with the `out`
 |          argument.
 |      
 |      out : ndarray, 2-dimensional, optional
 |          If specified, uses this array (or `numpy.matrix`) as the
 |          output buffer instead of allocating a new array to
 |          return. The provided array must have the same shape and
 |          dtype as the sparse matrix on which you are calling the
 |          method.
 |      
 |      Returns
 |      -------
 |      arr : numpy.matrix, 2-dimensional
 |          A NumPy matrix object with the same shape and containing
 |          the same data represented by the sparse matrix, with the
 |          requested memory order. If `out` was passed and was an
 |          array (rather than a `numpy.matrix`), it will be filled
 |          with the appropriate values and returned wrapped in a
 |          `numpy.matrix` object that shares the same memory.
 |  
 |  tolil(self, copy=False)
 |      Convert this matrix to LInked List format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant lil_matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.base.spmatrix:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  nnz
 |      Number of stored values, including explicit zeros.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  shape
 |      Get shape of a matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.sparse.base.spmatrix:
 |  
 |  __array_priority__ = 10.1
 |  
 |  __hash__ = None
 |  
 |  ndim = 2
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._minmax_mixin:
 |  
 |  argmax(self, axis=None, out=None)
 |      Return indices of maximum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several maximum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmax is computed. If None (default), index
 |          of the maximum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      ind : np.matrix or int
 |          Indices of maximum elements. If matrix, its size along `axis` is 1.
 |  
 |  argmin(self, axis=None, out=None)
 |      Return indices of minimum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several minimum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmin is computed. If None (default), index
 |          of the minimum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |       ind : np.matrix or int
 |          Indices of minimum elements. If matrix, its size along `axis` is 1.
 |  
 |  max(self, axis=None, out=None)
 |      Return the maximum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the maximum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amax : coo_matrix or scalar
 |          Maximum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      min : The minimum value of a sparse matrix along a given axis.
 |      np.matrix.max : NumPy's implementation of 'max' for matrices
 |  
 |  min(self, axis=None, out=None)
 |      Return the minimum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the minimum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amin : coo_matrix or scalar
 |          Minimum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      max : The maximum value of a sparse matrix along a given axis.
 |      np.matrix.min : NumPy's implementation of 'min' for matrices
",class,"('(self, arg1, shape=None, dtype=None, copy=False)',)",scipy,1.1.0,scipy.integrate._bvp.coo_matrix,integrate._bvp,coo_matrix,"Python Library Documentation: class coo_matrix in module scipy.sparse.coo

class coo_matrix(scipy.sparse.data._data_matrix, scipy.sparse.data._minmax_mixin)
 |  A sparse matrix in COOrdinate format.
 |  
 |  Also known as the 'ijv' or 'triplet' format.
 |  
 |  This can be instantiated in several ways:
 |      coo_matrix(D)
 |          with a dense matrix D
 |  
 |      coo_matrix(S)
 |          with another sparse matrix S (equivalent to S.tocoo())
 |  
 |      coo_matrix((M, N), [dtype])
 |          to construct an empty matrix with shape (M, N)
 |          dtype is optional, defaulting to dtype='d'.
 |  
 |      coo_matrix((data, (i, j)), [shape=(M, N)])
 |          to construct from three arrays:
 |              1. data[:]   the entries of the matrix, in any order
 |              2. i[:]      the row indices of the matrix entries
 |              3. j[:]      the column indices of the matrix entries
 |  
 |          Where ``A[i[k], j[k]] = data[k]``.  When shape is not
 |          specified, it is inferred from the index arrays
 |  
 |  Attributes
 |  ----------
 |  dtype : dtype
 |      Data type of the matrix
 |  shape : 2-tuple
 |      Shape of the matrix
 |  ndim : int
 |      Number of dimensions (this is always 2)
 |  nnz
 |      Number of nonzero elements
 |  data
 |      COO format data array of the matrix
 |  row
 |      COO format row index array of the matrix
 |  col
 |      COO format column index array of the matrix
 |  
 |  Notes
 |  -----
 |  
 |  Sparse matrices can be used in arithmetic operations: they support
 |  addition, subtraction, multiplication, division, and matrix power.
 |  
 |  Advantages of the COO format
 |      - facilitates fast conversion among sparse formats
 |      - permits duplicate entries (see example)
 |      - very fast conversion to and from CSR/CSC formats
 |  
 |  Disadvantages of the COO format
 |      - does not directly support:
 |          + arithmetic operations
 |          + slicing
 |  
 |  Intended Usage
 |      - COO is a fast format for constructing sparse matrices
 |      - Once a matrix has been constructed, convert to CSR or
 |        CSC format for fast arithmetic and matrix vector operations
 |      - By default when converting to CSR or CSC format, duplicate (i,j)
 |        entries will be summed together.  This facilitates efficient
 |        construction of finite element matrices and the like. (see example)
 |  
 |  Examples
 |  --------
 |  
 |  >>> # Constructing an empty matrix
 |  >>> from scipy.sparse import coo_matrix
 |  >>> coo_matrix((3, 4), dtype=np.int8).toarray()
 |  array([[0, 0, 0, 0],
 |         [0, 0, 0, 0],
 |         [0, 0, 0, 0]], dtype=int8)
 |  
 |  >>> # Constructing a matrix using ijv format
 |  >>> row  = np.array([0, 3, 1, 0])
 |  >>> col  = np.array([0, 3, 1, 2])
 |  >>> data = np.array([4, 5, 7, 9])
 |  >>> coo_matrix((data, (row, col)), shape=(4, 4)).toarray()
 |  array([[4, 0, 9, 0],
 |         [0, 7, 0, 0],
 |         [0, 0, 0, 0],
 |         [0, 0, 0, 5]])
 |  
 |  >>> # Constructing a matrix with duplicate indices
 |  >>> row  = np.array([0, 0, 1, 3, 1, 0, 0])
 |  >>> col  = np.array([0, 2, 1, 3, 1, 0, 0])
 |  >>> data = np.array([1, 1, 1, 1, 1, 1, 1])
 |  >>> coo = coo_matrix((data, (row, col)), shape=(4, 4))
 |  >>> # Duplicate indices are maintained until implicitly or explicitly summed
 |  >>> np.max(coo.data)
 |  1
 |  >>> coo.toarray()
 |  array([[3, 0, 1, 0],
 |         [0, 2, 0, 0],
 |         [0, 0, 0, 0],
 |         [0, 0, 0, 1]])
 |  
 |  Method resolution order:
 |      coo_matrix
 |      scipy.sparse.data._data_matrix
 |      scipy.sparse.base.spmatrix
 |      scipy.sparse.data._minmax_mixin
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, arg1, shape=None, dtype=None, copy=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  diagonal(self, k=0)
 |      Returns the k-th diagonal of the matrix.
 |      
 |      Parameters
 |      ----------
 |      k : int, optional
 |          Which diagonal to set, corresponding to elements a[i, i+k].
 |          Default: 0 (the main diagonal).
 |      
 |          .. versionadded:: 1.0
 |      
 |      See also
 |      --------
 |      numpy.diagonal : Equivalent numpy function.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> A.diagonal()
 |      array([1, 0, 5])
 |      >>> A.diagonal(k=1)
 |      array([2, 3])
 |  
 |  eliminate_zeros(self)
 |      Remove zero entries from the matrix
 |      
 |      This is an *in place* operation
 |  
 |  getnnz(self, axis=None)
 |      Number of stored values, including explicit zeros.
 |      
 |      Parameters
 |      ----------
 |      axis : None, 0, or 1
 |          Select between the number of values across the whole matrix, in
 |          each column, or in each row.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  reshape(self, *args, **kwargs)
 |      reshape(self, shape, order='C', copy=False)
 |      
 |      Gives a new shape to a sparse matrix without changing its data.
 |      
 |      Parameters
 |      ----------
 |      shape : length-2 tuple of ints
 |          The new shape should be compatible with the original shape.
 |      order : {'C', 'F'}, optional
 |          Read the elements using this index order. 'C' means to read and
 |          write the elements using C-like index order; e.g. read entire first
 |          row, then second row, etc. 'F' means to read and write the elements
 |          using Fortran-like index order; e.g. read entire first column, then
 |          second column, etc.
 |      copy : bool, optional
 |          Indicates whether or not attributes of self should be copied
 |          whenever possible. The degree to which attributes are copied varies
 |          depending on the type of sparse matrix being used.
 |      
 |      Returns
 |      -------
 |      reshaped_matrix : sparse matrix
 |          A sparse matrix with the given `shape`, not necessarily of the same
 |          format as the current object.
 |      
 |      See Also
 |      --------
 |      np.matrix.reshape : NumPy's implementation of 'reshape' for matrices
 |  
 |  resize(self, *shape)
 |      Resize the matrix in-place to dimensions given by ``shape``
 |      
 |      Any elements that lie within the new shape will remain at the same
 |      indices, while non-zero elements lying outside the new shape are
 |      removed.
 |      
 |      Parameters
 |      ----------
 |      shape : (int, int)
 |          number of rows and columns in the new matrix
 |      
 |      Notes
 |      -----
 |      The semantics are not identical to `numpy.ndarray.resize` or
 |      `numpy.resize`.  Here, the same data will be maintained at each index
 |      before and after reshape, if that index is within the new bounds.  In
 |      numpy, resizing maintains contiguity of the array, moving elements
 |      around in the logical matrix but not within a flattened representation.
 |      
 |      We give no guarantees about whether the underlying data attributes
 |      (arrays, etc.) will be modified in place or replaced with new objects.
 |  
 |  sum_duplicates(self)
 |      Eliminate duplicate matrix entries by adding them together
 |      
 |      This is an *in place* operation
 |  
 |  toarray(self, order=None, out=None)
 |      See the docstring for `spmatrix.toarray`.
 |  
 |  tocoo(self, copy=False)
 |      Convert this matrix to COOrdinate format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant coo_matrix.
 |  
 |  tocsc(self, copy=False)
 |      Convert this matrix to Compressed Sparse Column format
 |      
 |      Duplicate entries will be summed together.
 |      
 |      Examples
 |      --------
 |      >>> from numpy import array
 |      >>> from scipy.sparse import coo_matrix
 |      >>> row  = array([0, 0, 1, 3, 1, 0, 0])
 |      >>> col  = array([0, 2, 1, 3, 1, 0, 0])
 |      >>> data = array([1, 1, 1, 1, 1, 1, 1])
 |      >>> A = coo_matrix((data, (row, col)), shape=(4, 4)).tocsc()
 |      >>> A.toarray()
 |      array([[3, 0, 1, 0],
 |             [0, 2, 0, 0],
 |             [0, 0, 0, 0],
 |             [0, 0, 0, 1]])
 |  
 |  tocsr(self, copy=False)
 |      Convert this matrix to Compressed Sparse Row format
 |      
 |      Duplicate entries will be summed together.
 |      
 |      Examples
 |      --------
 |      >>> from numpy import array
 |      >>> from scipy.sparse import coo_matrix
 |      >>> row  = array([0, 0, 1, 3, 1, 0, 0])
 |      >>> col  = array([0, 2, 1, 3, 1, 0, 0])
 |      >>> data = array([1, 1, 1, 1, 1, 1, 1])
 |      >>> A = coo_matrix((data, (row, col)), shape=(4, 4)).tocsr()
 |      >>> A.toarray()
 |      array([[3, 0, 1, 0],
 |             [0, 2, 0, 0],
 |             [0, 0, 0, 0],
 |             [0, 0, 0, 1]])
 |  
 |  todia(self, copy=False)
 |      Convert this matrix to sparse DIAgonal format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dia_matrix.
 |  
 |  todok(self, copy=False)
 |      Convert this matrix to Dictionary Of Keys format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dok_matrix.
 |  
 |  transpose(self, axes=None, copy=False)
 |      Reverses the dimensions of the sparse matrix.
 |      
 |      Parameters
 |      ----------
 |      axes : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value.
 |      copy : bool, optional
 |          Indicates whether or not attributes of `self` should be
 |          copied whenever possible. The degree to which attributes
 |          are copied varies depending on the type of sparse matrix
 |          being used.
 |      
 |      Returns
 |      -------
 |      p : `self` with the dimensions reversed.
 |      
 |      See Also
 |      --------
 |      np.matrix.transpose : NumPy's implementation of 'transpose'
 |                            for matrices
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  format = 'coo'
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._data_matrix:
 |  
 |  __abs__(self)
 |  
 |  __imul__(self, other)
 |  
 |  __itruediv__(self, other)
 |  
 |  __neg__(self)
 |  
 |  arcsin(self)
 |      Element-wise arcsin.
 |      
 |      See numpy.arcsin for more information.
 |  
 |  arcsinh(self)
 |      Element-wise arcsinh.
 |      
 |      See numpy.arcsinh for more information.
 |  
 |  arctan(self)
 |      Element-wise arctan.
 |      
 |      See numpy.arctan for more information.
 |  
 |  arctanh(self)
 |      Element-wise arctanh.
 |      
 |      See numpy.arctanh for more information.
 |  
 |  astype(self, dtype, casting='unsafe', copy=True)
 |      Cast the matrix elements to a specified type.
 |      
 |      Parameters
 |      ----------
 |      dtype : string or numpy dtype
 |          Typecode or data-type to which to cast the data.
 |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
 |          Controls what kind of data casting may occur.
 |          Defaults to 'unsafe' for backwards compatibility.
 |          'no' means the data types should not be cast at all.
 |          'equiv' means only byte-order changes are allowed.
 |          'safe' means only casts which can preserve values are allowed.
 |          'same_kind' means only safe casts or casts within a kind,
 |          like float64 to float32, are allowed.
 |          'unsafe' means any data conversions may be done.
 |      copy : bool, optional
 |          If `copy` is `False`, the result might share some memory with this
 |          matrix. If `copy` is `True`, it is guaranteed that the result and
 |          this matrix do not share any memory.
 |  
 |  ceil(self)
 |      Element-wise ceil.
 |      
 |      See numpy.ceil for more information.
 |  
 |  conj(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  copy(self)
 |      Returns a copy of this matrix.
 |      
 |      No data/indices will be shared between the returned value and current
 |      matrix.
 |  
 |  count_nonzero(self)
 |      Number of non-zero entries, equivalent to
 |      
 |      np.count_nonzero(a.toarray())
 |      
 |      Unlike getnnz() and the nnz property, which return the number of stored
 |      entries (the length of the data attribute), this method counts the
 |      actual number of non-zero entries in data.
 |  
 |  deg2rad(self)
 |      Element-wise deg2rad.
 |      
 |      See numpy.deg2rad for more information.
 |  
 |  expm1(self)
 |      Element-wise expm1.
 |      
 |      See numpy.expm1 for more information.
 |  
 |  floor(self)
 |      Element-wise floor.
 |      
 |      See numpy.floor for more information.
 |  
 |  log1p(self)
 |      Element-wise log1p.
 |      
 |      See numpy.log1p for more information.
 |  
 |  power(self, n, dtype=None)
 |      This function performs element-wise power.
 |      
 |      Parameters
 |      ----------
 |      n : n is a scalar
 |      
 |      dtype : If dtype is not specified, the current dtype will be preserved.
 |  
 |  rad2deg(self)
 |      Element-wise rad2deg.
 |      
 |      See numpy.rad2deg for more information.
 |  
 |  rint(self)
 |      Element-wise rint.
 |      
 |      See numpy.rint for more information.
 |  
 |  sign(self)
 |      Element-wise sign.
 |      
 |      See numpy.sign for more information.
 |  
 |  sin(self)
 |      Element-wise sin.
 |      
 |      See numpy.sin for more information.
 |  
 |  sinh(self)
 |      Element-wise sinh.
 |      
 |      See numpy.sinh for more information.
 |  
 |  sqrt(self)
 |      Element-wise sqrt.
 |      
 |      See numpy.sqrt for more information.
 |  
 |  tan(self)
 |      Element-wise tan.
 |      
 |      See numpy.tan for more information.
 |  
 |  tanh(self)
 |      Element-wise tanh.
 |      
 |      See numpy.tanh for more information.
 |  
 |  trunc(self)
 |      Element-wise trunc.
 |      
 |      See numpy.trunc for more information.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.data._data_matrix:
 |  
 |  dtype
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.base.spmatrix:
 |  
 |  __add__(self, other)
 |  
 |  __bool__(self)
 |  
 |  __div__(self, other)
 |  
 |  __eq__(self, other)
 |      Return self==value.
 |  
 |  __ge__(self, other)
 |      Return self>=value.
 |  
 |  __getattr__(self, attr)
 |  
 |  __gt__(self, other)
 |      Return self>value.
 |  
 |  __iadd__(self, other)
 |  
 |  __idiv__(self, other)
 |  
 |  __isub__(self, other)
 |  
 |  __iter__(self)
 |  
 |  __le__(self, other)
 |      Return self<=value.
 |  
 |  __len__(self)
 |      # What should len(sparse) return? For consistency with dense matrices,
 |      # perhaps it should be the number of rows?  But for some uses the number of
 |      # non-zeros is more important.  For now, raise an exception!
 |  
 |  __lt__(self, other)
 |      Return self<value.
 |  
 |  __matmul__(self, other)
 |  
 |  __mul__(self, other)
 |      interpret other and call one of the following
 |      
 |      self._mul_scalar()
 |      self._mul_vector()
 |      self._mul_multivector()
 |      self._mul_sparse_matrix()
 |  
 |  __ne__(self, other)
 |      Return self!=value.
 |  
 |  __nonzero__ = __bool__(self)
 |  
 |  __pow__(self, other)
 |  
 |  __radd__(self, other)
 |  
 |  __rdiv__(self, other)
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __rmatmul__(self, other)
 |  
 |  __rmul__(self, other)
 |  
 |  __rsub__(self, other)
 |  
 |  __rtruediv__(self, other)
 |  
 |  __str__(self)
 |      Return str(self).
 |  
 |  __sub__(self, other)
 |  
 |  __truediv__(self, other)
 |  
 |  asformat(self, format, copy=False)
 |      Return this matrix in the passed sparse format.
 |      
 |      Parameters
 |      ----------
 |      format : {str, None}
 |          The desired sparse matrix format (""csr"", ""csc"", ""lil"", ""dok"", ...)
 |          or None for no conversion.
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : This matrix in the passed sparse format.
 |  
 |  asfptype(self)
 |      Upcast matrix to a floating point format (if necessary)
 |  
 |  conjugate(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  dot(self, other)
 |      Ordinary dot product
 |      
 |      Examples
 |      --------
 |      >>> import numpy as np
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> v = np.array([1, 0, -1])
 |      >>> A.dot(v)
 |      array([ 1, -3, -1], dtype=int64)
 |  
 |  getH(self)
 |      Return the Hermitian transpose of this matrix.
 |      
 |      See Also
 |      --------
 |      np.matrix.getH : NumPy's implementation of `getH` for matrices
 |  
 |  get_shape(self)
 |      Get shape of a matrix.
 |  
 |  getcol(self, j)
 |      Returns a copy of column j of the matrix, as an (m x 1) sparse
 |      matrix (column vector).
 |  
 |  getformat(self)
 |      Format of a matrix representation as a string.
 |  
 |  getmaxprint(self)
 |      Maximum number of elements to display when printed.
 |  
 |  getrow(self, i)
 |      Returns a copy of row i of the matrix, as a (1 x n) sparse
 |      matrix (row vector).
 |  
 |  maximum(self, other)
 |      Element-wise maximum between this and another matrix.
 |  
 |  mean(self, axis=None, dtype=None, out=None)
 |      Compute the arithmetic mean along the specified axis.
 |      
 |      Returns the average of the matrix elements. The average is taken
 |      over all elements in the matrix by default, otherwise over the
 |      specified axis. `float64` intermediate and return values are used
 |      for integer inputs.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the mean is computed. The default is to compute
 |          the mean of all elements in the matrix (i.e. `axis` = `None`).
 |      dtype : data-type, optional
 |          Type to use in computing the mean. For integer inputs, the default
 |          is `float64`; for floating point inputs, it is the same as the
 |          input dtype.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      m : np.matrix
 |      
 |      See Also
 |      --------
 |      np.matrix.mean : NumPy's implementation of 'mean' for matrices
 |  
 |  minimum(self, other)
 |      Element-wise minimum between this and another matrix.
 |  
 |  multiply(self, other)
 |      Point-wise multiplication by another matrix
 |  
 |  nonzero(self)
 |      nonzero indices
 |      
 |      Returns a tuple of arrays (row,col) containing the indices
 |      of the non-zero elements of the matrix.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1,2,0],[0,0,3],[4,0,5]])
 |      >>> A.nonzero()
 |      (array([0, 0, 1, 2, 2]), array([0, 1, 2, 0, 2]))
 |  
 |  set_shape(self, shape)
 |      See `reshape`.
 |  
 |  setdiag(self, values, k=0)
 |      Set diagonal or off-diagonal elements of the array.
 |      
 |      Parameters
 |      ----------
 |      values : array_like
 |          New values of the diagonal elements.
 |      
 |          Values may have any length.  If the diagonal is longer than values,
 |          then the remaining diagonal entries will not be set.  If values if
 |          longer than the diagonal, then the remaining values are ignored.
 |      
 |          If a scalar value is given, all of the diagonal is set to it.
 |      
 |      k : int, optional
 |          Which off-diagonal to set, corresponding to elements a[i,i+k].
 |          Default: 0 (the main diagonal).
 |  
 |  sum(self, axis=None, dtype=None, out=None)
 |      Sum the matrix elements over a given axis.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the sum of all the matrix elements, returning a scalar
 |          (i.e. `axis` = `None`).
 |      dtype : dtype, optional
 |          The type of the returned matrix and of the accumulator in which
 |          the elements are summed.  The dtype of `a` is used by default
 |          unless `a` has an integer dtype of less precision than the default
 |          platform integer.  In that case, if `a` is signed then the platform
 |          integer is used while if `a` is unsigned then an unsigned integer
 |          of the same precision as the platform integer is used.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      sum_along_axis : np.matrix
 |          A matrix with the same shape as `self`, with the specified
 |          axis removed.
 |      
 |      See Also
 |      --------
 |      np.matrix.sum : NumPy's implementation of 'sum' for matrices
 |  
 |  tobsr(self, blocksize=None, copy=False)
 |      Convert this matrix to Block Sparse Row format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant bsr_matrix.
 |      
 |      When blocksize=(R, C) is provided, it will be used for construction of
 |      the bsr_matrix.
 |  
 |  todense(self, order=None, out=None)
 |      Return a dense matrix representation of this matrix.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F'}, optional
 |          Whether to store multi-dimensional data in C (row-major)
 |          or Fortran (column-major) order in memory. The default
 |          is 'None', indicating the NumPy default of C-ordered.
 |          Cannot be specified in conjunction with the `out`
 |          argument.
 |      
 |      out : ndarray, 2-dimensional, optional
 |          If specified, uses this array (or `numpy.matrix`) as the
 |          output buffer instead of allocating a new array to
 |          return. The provided array must have the same shape and
 |          dtype as the sparse matrix on which you are calling the
 |          method.
 |      
 |      Returns
 |      -------
 |      arr : numpy.matrix, 2-dimensional
 |          A NumPy matrix object with the same shape and containing
 |          the same data represented by the sparse matrix, with the
 |          requested memory order. If `out` was passed and was an
 |          array (rather than a `numpy.matrix`), it will be filled
 |          with the appropriate values and returned wrapped in a
 |          `numpy.matrix` object that shares the same memory.
 |  
 |  tolil(self, copy=False)
 |      Convert this matrix to LInked List format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant lil_matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.base.spmatrix:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  nnz
 |      Number of stored values, including explicit zeros.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  shape
 |      Get shape of a matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.sparse.base.spmatrix:
 |  
 |  __array_priority__ = 10.1
 |  
 |  __hash__ = None
 |  
 |  ndim = 2
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._minmax_mixin:
 |  
 |  argmax(self, axis=None, out=None)
 |      Return indices of maximum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several maximum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmax is computed. If None (default), index
 |          of the maximum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      ind : np.matrix or int
 |          Indices of maximum elements. If matrix, its size along `axis` is 1.
 |  
 |  argmin(self, axis=None, out=None)
 |      Return indices of minimum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several minimum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmin is computed. If None (default), index
 |          of the minimum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |       ind : np.matrix or int
 |          Indices of minimum elements. If matrix, its size along `axis` is 1.
 |  
 |  max(self, axis=None, out=None)
 |      Return the maximum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the maximum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amax : coo_matrix or scalar
 |          Maximum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      min : The minimum value of a sparse matrix along a given axis.
 |      np.matrix.max : NumPy's implementation of 'max' for matrices
 |  
 |  min(self, axis=None, out=None)
 |      Return the minimum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the minimum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amin : coo_matrix or scalar
 |          Minimum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      max : The maximum value of a sparse matrix along a given axis.
 |      np.matrix.min : NumPy's implementation of 'min' for matrices
",class,"('self', 'arg1', 'shape', 'dtype', 'copy')","(nan, nan, None, None, False)","(nan, nan, 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, arg1, shape=None, dtype=None, copy=False)',)"
scipy,1.1.0,scipy.integrate._bvp.create_spline,integrate._bvp,create_spline,"Python Library Documentation: function create_spline in module scipy.integrate._bvp

create_spline(y, yp, x, h)
    Create a cubic spline given values and derivatives.
    
    Formulas for the coefficients are taken from interpolate.CubicSpline.
    
    Returns
    -------
    sol : PPoly
        Constructed spline as a PPoly instance.
",function,"('(y, yp, x, h)',)",scipy,1.1.0,scipy.integrate._bvp.create_spline,integrate._bvp,create_spline,"Python Library Documentation: function create_spline in module scipy.integrate._bvp

create_spline(y, yp, x, h)
    Create a cubic spline given values and derivatives.
    
    Formulas for the coefficients are taken from interpolate.CubicSpline.
    
    Returns
    -------
    sol : PPoly
        Constructed spline as a PPoly instance.
",function,"('y', 'yp', 'x', 'h')","(nan, nan, nan, nan)","(nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(y, yp, x, h)',)"
scipy,1.1.0,scipy.integrate._bvp.csc_matrix,integrate._bvp,csc_matrix,"Python Library Documentation: class csc_matrix in module scipy.sparse.csc

class csc_matrix(scipy.sparse.compressed._cs_matrix, scipy.sparse.sputils.IndexMixin)
 |  Compressed Sparse Column matrix
 |  
 |  This can be instantiated in several ways:
 |  
 |      csc_matrix(D)
 |          with a dense matrix or rank-2 ndarray D
 |  
 |      csc_matrix(S)
 |          with another sparse matrix S (equivalent to S.tocsc())
 |  
 |      csc_matrix((M, N), [dtype])
 |          to construct an empty matrix with shape (M, N)
 |          dtype is optional, defaulting to dtype='d'.
 |  
 |      csc_matrix((data, (row_ind, col_ind)), [shape=(M, N)])
 |          where ``data``, ``row_ind`` and ``col_ind`` satisfy the
 |          relationship ``a[row_ind[k], col_ind[k]] = data[k]``.
 |  
 |      csc_matrix((data, indices, indptr), [shape=(M, N)])
 |          is the standard CSC representation where the row indices for
 |          column i are stored in ``indices[indptr[i]:indptr[i+1]]``
 |          and their corresponding values are stored in
 |          ``data[indptr[i]:indptr[i+1]]``.  If the shape parameter is
 |          not supplied, the matrix dimensions are inferred from
 |          the index arrays.
 |  
 |  Attributes
 |  ----------
 |  dtype : dtype
 |      Data type of the matrix
 |  shape : 2-tuple
 |      Shape of the matrix
 |  ndim : int
 |      Number of dimensions (this is always 2)
 |  nnz
 |      Number of nonzero elements
 |  data
 |      Data array of the matrix
 |  indices
 |      CSC format index array
 |  indptr
 |      CSC format index pointer array
 |  has_sorted_indices
 |      Whether indices are sorted
 |  
 |  Notes
 |  -----
 |  
 |  Sparse matrices can be used in arithmetic operations: they support
 |  addition, subtraction, multiplication, division, and matrix power.
 |  
 |  Advantages of the CSC format
 |      - efficient arithmetic operations CSC + CSC, CSC * CSC, etc.
 |      - efficient column slicing
 |      - fast matrix vector products (CSR, BSR may be faster)
 |  
 |  Disadvantages of the CSC format
 |    - slow row slicing operations (consider CSR)
 |    - changes to the sparsity structure are expensive (consider LIL or DOK)
 |  
 |  
 |  Examples
 |  --------
 |  
 |  >>> import numpy as np
 |  >>> from scipy.sparse import csc_matrix
 |  >>> csc_matrix((3, 4), dtype=np.int8).toarray()
 |  array([[0, 0, 0, 0],
 |         [0, 0, 0, 0],
 |         [0, 0, 0, 0]], dtype=int8)
 |  
 |  >>> row = np.array([0, 2, 2, 0, 1, 2])
 |  >>> col = np.array([0, 0, 1, 2, 2, 2])
 |  >>> data = np.array([1, 2, 3, 4, 5, 6])
 |  >>> csc_matrix((data, (row, col)), shape=(3, 3)).toarray()
 |  array([[1, 0, 4],
 |         [0, 0, 5],
 |         [2, 3, 6]])
 |  
 |  >>> indptr = np.array([0, 2, 3, 6])
 |  >>> indices = np.array([0, 2, 2, 0, 1, 2])
 |  >>> data = np.array([1, 2, 3, 4, 5, 6])
 |  >>> csc_matrix((data, indices, indptr), shape=(3, 3)).toarray()
 |  array([[1, 0, 4],
 |         [0, 0, 5],
 |         [2, 3, 6]])
 |  
 |  Method resolution order:
 |      csc_matrix
 |      scipy.sparse.compressed._cs_matrix
 |      scipy.sparse.data._data_matrix
 |      scipy.sparse.base.spmatrix
 |      scipy.sparse.data._minmax_mixin
 |      scipy.sparse.sputils.IndexMixin
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __getitem__(self, key)
 |  
 |  __iter__(self)
 |  
 |  getcol(self, i)
 |      Returns a copy of column i of the matrix, as a (m x 1)
 |      CSC matrix (column vector).
 |  
 |  getrow(self, i)
 |      Returns a copy of row i of the matrix, as a (1 x n)
 |      CSR matrix (row vector).
 |  
 |  nonzero(self)
 |      nonzero indices
 |      
 |      Returns a tuple of arrays (row,col) containing the indices
 |      of the non-zero elements of the matrix.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1,2,0],[0,0,3],[4,0,5]])
 |      >>> A.nonzero()
 |      (array([0, 0, 1, 2, 2]), array([0, 1, 2, 0, 2]))
 |  
 |  tocsc(self, copy=False)
 |      Convert this matrix to Compressed Sparse Column format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant csc_matrix.
 |  
 |  tocsr(self, copy=False)
 |      Convert this matrix to Compressed Sparse Row format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant csr_matrix.
 |  
 |  transpose(self, axes=None, copy=False)
 |      Reverses the dimensions of the sparse matrix.
 |      
 |      Parameters
 |      ----------
 |      axes : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value.
 |      copy : bool, optional
 |          Indicates whether or not attributes of `self` should be
 |          copied whenever possible. The degree to which attributes
 |          are copied varies depending on the type of sparse matrix
 |          being used.
 |      
 |      Returns
 |      -------
 |      p : `self` with the dimensions reversed.
 |      
 |      See Also
 |      --------
 |      np.matrix.transpose : NumPy's implementation of 'transpose'
 |                            for matrices
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  format = 'csc'
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.compressed._cs_matrix:
 |  
 |  __eq__(self, other)
 |      Return self==value.
 |  
 |  __ge__(self, other)
 |      Return self>=value.
 |  
 |  __gt__(self, other)
 |      Return self>value.
 |  
 |  __init__(self, arg1, shape=None, dtype=None, copy=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __le__(self, other)
 |      Return self<=value.
 |  
 |  __lt__(self, other)
 |      Return self<value.
 |  
 |  __ne__(self, other)
 |      Return self!=value.
 |  
 |  __setitem__(self, index, x)
 |  
 |  check_format(self, full_check=True)
 |      check whether the matrix format is valid
 |      
 |      Parameters
 |      ----------
 |      full_check : bool, optional
 |          If `True`, rigorous check, O(N) operations. Otherwise
 |          basic check, O(1) operations (default True).
 |  
 |  diagonal(self, k=0)
 |      Returns the k-th diagonal of the matrix.
 |      
 |      Parameters
 |      ----------
 |      k : int, optional
 |          Which diagonal to set, corresponding to elements a[i, i+k].
 |          Default: 0 (the main diagonal).
 |      
 |          .. versionadded:: 1.0
 |      
 |      See also
 |      --------
 |      numpy.diagonal : Equivalent numpy function.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> A.diagonal()
 |      array([1, 0, 5])
 |      >>> A.diagonal(k=1)
 |      array([2, 3])
 |  
 |  eliminate_zeros(self)
 |      Remove zero entries from the matrix
 |      
 |      This is an *in place* operation
 |  
 |  getnnz(self, axis=None)
 |      Number of stored values, including explicit zeros.
 |      
 |      Parameters
 |      ----------
 |      axis : None, 0, or 1
 |          Select between the number of values across the whole matrix, in
 |          each column, or in each row.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  maximum(self, other)
 |      Element-wise maximum between this and another matrix.
 |  
 |  minimum(self, other)
 |      Element-wise minimum between this and another matrix.
 |  
 |  multiply(self, other)
 |      Point-wise multiplication by another matrix, vector, or
 |      scalar.
 |  
 |  prune(self)
 |      Remove empty space after all non-zero elements.
 |  
 |  resize(self, *shape)
 |      Resize the matrix in-place to dimensions given by ``shape``
 |      
 |      Any elements that lie within the new shape will remain at the same
 |      indices, while non-zero elements lying outside the new shape are
 |      removed.
 |      
 |      Parameters
 |      ----------
 |      shape : (int, int)
 |          number of rows and columns in the new matrix
 |      
 |      Notes
 |      -----
 |      The semantics are not identical to `numpy.ndarray.resize` or
 |      `numpy.resize`.  Here, the same data will be maintained at each index
 |      before and after reshape, if that index is within the new bounds.  In
 |      numpy, resizing maintains contiguity of the array, moving elements
 |      around in the logical matrix but not within a flattened representation.
 |      
 |      We give no guarantees about whether the underlying data attributes
 |      (arrays, etc.) will be modified in place or replaced with new objects.
 |  
 |  sort_indices(self)
 |      Sort the indices of this matrix *in place*
 |  
 |  sorted_indices(self)
 |      Return a copy of this matrix with sorted indices
 |  
 |  sum(self, axis=None, dtype=None, out=None)
 |      Sum the matrix elements over a given axis.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the sum of all the matrix elements, returning a scalar
 |          (i.e. `axis` = `None`).
 |      dtype : dtype, optional
 |          The type of the returned matrix and of the accumulator in which
 |          the elements are summed.  The dtype of `a` is used by default
 |          unless `a` has an integer dtype of less precision than the default
 |          platform integer.  In that case, if `a` is signed then the platform
 |          integer is used while if `a` is unsigned then an unsigned integer
 |          of the same precision as the platform integer is used.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      sum_along_axis : np.matrix
 |          A matrix with the same shape as `self`, with the specified
 |          axis removed.
 |      
 |      See Also
 |      --------
 |      np.matrix.sum : NumPy's implementation of 'sum' for matrices
 |  
 |  sum_duplicates(self)
 |      Eliminate duplicate matrix entries by adding them together
 |      
 |      The is an *in place* operation
 |  
 |  toarray(self, order=None, out=None)
 |      Return a dense ndarray representation of this matrix.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F'}, optional
 |          Whether to store multi-dimensional data in C (row-major)
 |          or Fortran (column-major) order in memory. The default
 |          is 'None', indicating the NumPy default of C-ordered.
 |          Cannot be specified in conjunction with the `out`
 |          argument.
 |      
 |      out : ndarray, 2-dimensional, optional
 |          If specified, uses this array as the output buffer
 |          instead of allocating a new array to return. The provided
 |          array must have the same shape and dtype as the sparse
 |          matrix on which you are calling the method. For most
 |          sparse types, `out` is required to be memory contiguous
 |          (either C or Fortran ordered).
 |      
 |      Returns
 |      -------
 |      arr : ndarray, 2-dimensional
 |          An array with the same shape and containing the same
 |          data represented by the sparse matrix, with the requested
 |          memory order. If `out` was passed, the same object is
 |          returned after being modified in-place to contain the
 |          appropriate values.
 |  
 |  tocoo(self, copy=True)
 |      Convert this matrix to COOrdinate format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant coo_matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.compressed._cs_matrix:
 |  
 |  has_canonical_format
 |      Determine whether the matrix has sorted indices and no duplicates
 |      
 |      Returns
 |          - True: if the above applies
 |          - False: otherwise
 |      
 |      has_canonical_format implies has_sorted_indices, so if the latter flag
 |      is False, so will the former be; if the former is found True, the
 |      latter flag is also set.
 |  
 |  has_sorted_indices
 |      Determine whether the matrix has sorted indices
 |      
 |      Returns
 |          - True: if the indices of the matrix are in sorted order
 |          - False: otherwise
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.sparse.compressed._cs_matrix:
 |  
 |  __hash__ = None
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._data_matrix:
 |  
 |  __abs__(self)
 |  
 |  __imul__(self, other)
 |  
 |  __itruediv__(self, other)
 |  
 |  __neg__(self)
 |  
 |  arcsin(self)
 |      Element-wise arcsin.
 |      
 |      See numpy.arcsin for more information.
 |  
 |  arcsinh(self)
 |      Element-wise arcsinh.
 |      
 |      See numpy.arcsinh for more information.
 |  
 |  arctan(self)
 |      Element-wise arctan.
 |      
 |      See numpy.arctan for more information.
 |  
 |  arctanh(self)
 |      Element-wise arctanh.
 |      
 |      See numpy.arctanh for more information.
 |  
 |  astype(self, dtype, casting='unsafe', copy=True)
 |      Cast the matrix elements to a specified type.
 |      
 |      Parameters
 |      ----------
 |      dtype : string or numpy dtype
 |          Typecode or data-type to which to cast the data.
 |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
 |          Controls what kind of data casting may occur.
 |          Defaults to 'unsafe' for backwards compatibility.
 |          'no' means the data types should not be cast at all.
 |          'equiv' means only byte-order changes are allowed.
 |          'safe' means only casts which can preserve values are allowed.
 |          'same_kind' means only safe casts or casts within a kind,
 |          like float64 to float32, are allowed.
 |          'unsafe' means any data conversions may be done.
 |      copy : bool, optional
 |          If `copy` is `False`, the result might share some memory with this
 |          matrix. If `copy` is `True`, it is guaranteed that the result and
 |          this matrix do not share any memory.
 |  
 |  ceil(self)
 |      Element-wise ceil.
 |      
 |      See numpy.ceil for more information.
 |  
 |  conj(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  copy(self)
 |      Returns a copy of this matrix.
 |      
 |      No data/indices will be shared between the returned value and current
 |      matrix.
 |  
 |  count_nonzero(self)
 |      Number of non-zero entries, equivalent to
 |      
 |      np.count_nonzero(a.toarray())
 |      
 |      Unlike getnnz() and the nnz property, which return the number of stored
 |      entries (the length of the data attribute), this method counts the
 |      actual number of non-zero entries in data.
 |  
 |  deg2rad(self)
 |      Element-wise deg2rad.
 |      
 |      See numpy.deg2rad for more information.
 |  
 |  expm1(self)
 |      Element-wise expm1.
 |      
 |      See numpy.expm1 for more information.
 |  
 |  floor(self)
 |      Element-wise floor.
 |      
 |      See numpy.floor for more information.
 |  
 |  log1p(self)
 |      Element-wise log1p.
 |      
 |      See numpy.log1p for more information.
 |  
 |  power(self, n, dtype=None)
 |      This function performs element-wise power.
 |      
 |      Parameters
 |      ----------
 |      n : n is a scalar
 |      
 |      dtype : If dtype is not specified, the current dtype will be preserved.
 |  
 |  rad2deg(self)
 |      Element-wise rad2deg.
 |      
 |      See numpy.rad2deg for more information.
 |  
 |  rint(self)
 |      Element-wise rint.
 |      
 |      See numpy.rint for more information.
 |  
 |  sign(self)
 |      Element-wise sign.
 |      
 |      See numpy.sign for more information.
 |  
 |  sin(self)
 |      Element-wise sin.
 |      
 |      See numpy.sin for more information.
 |  
 |  sinh(self)
 |      Element-wise sinh.
 |      
 |      See numpy.sinh for more information.
 |  
 |  sqrt(self)
 |      Element-wise sqrt.
 |      
 |      See numpy.sqrt for more information.
 |  
 |  tan(self)
 |      Element-wise tan.
 |      
 |      See numpy.tan for more information.
 |  
 |  tanh(self)
 |      Element-wise tanh.
 |      
 |      See numpy.tanh for more information.
 |  
 |  trunc(self)
 |      Element-wise trunc.
 |      
 |      See numpy.trunc for more information.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.data._data_matrix:
 |  
 |  dtype
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.base.spmatrix:
 |  
 |  __add__(self, other)
 |  
 |  __bool__(self)
 |  
 |  __div__(self, other)
 |  
 |  __getattr__(self, attr)
 |  
 |  __iadd__(self, other)
 |  
 |  __idiv__(self, other)
 |  
 |  __isub__(self, other)
 |  
 |  __len__(self)
 |      # What should len(sparse) return? For consistency with dense matrices,
 |      # perhaps it should be the number of rows?  But for some uses the number of
 |      # non-zeros is more important.  For now, raise an exception!
 |  
 |  __matmul__(self, other)
 |  
 |  __mul__(self, other)
 |      interpret other and call one of the following
 |      
 |      self._mul_scalar()
 |      self._mul_vector()
 |      self._mul_multivector()
 |      self._mul_sparse_matrix()
 |  
 |  __nonzero__ = __bool__(self)
 |  
 |  __pow__(self, other)
 |  
 |  __radd__(self, other)
 |  
 |  __rdiv__(self, other)
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __rmatmul__(self, other)
 |  
 |  __rmul__(self, other)
 |  
 |  __rsub__(self, other)
 |  
 |  __rtruediv__(self, other)
 |  
 |  __str__(self)
 |      Return str(self).
 |  
 |  __sub__(self, other)
 |  
 |  __truediv__(self, other)
 |  
 |  asformat(self, format, copy=False)
 |      Return this matrix in the passed sparse format.
 |      
 |      Parameters
 |      ----------
 |      format : {str, None}
 |          The desired sparse matrix format (""csr"", ""csc"", ""lil"", ""dok"", ...)
 |          or None for no conversion.
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : This matrix in the passed sparse format.
 |  
 |  asfptype(self)
 |      Upcast matrix to a floating point format (if necessary)
 |  
 |  conjugate(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  dot(self, other)
 |      Ordinary dot product
 |      
 |      Examples
 |      --------
 |      >>> import numpy as np
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> v = np.array([1, 0, -1])
 |      >>> A.dot(v)
 |      array([ 1, -3, -1], dtype=int64)
 |  
 |  getH(self)
 |      Return the Hermitian transpose of this matrix.
 |      
 |      See Also
 |      --------
 |      np.matrix.getH : NumPy's implementation of `getH` for matrices
 |  
 |  get_shape(self)
 |      Get shape of a matrix.
 |  
 |  getformat(self)
 |      Format of a matrix representation as a string.
 |  
 |  getmaxprint(self)
 |      Maximum number of elements to display when printed.
 |  
 |  mean(self, axis=None, dtype=None, out=None)
 |      Compute the arithmetic mean along the specified axis.
 |      
 |      Returns the average of the matrix elements. The average is taken
 |      over all elements in the matrix by default, otherwise over the
 |      specified axis. `float64` intermediate and return values are used
 |      for integer inputs.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the mean is computed. The default is to compute
 |          the mean of all elements in the matrix (i.e. `axis` = `None`).
 |      dtype : data-type, optional
 |          Type to use in computing the mean. For integer inputs, the default
 |          is `float64`; for floating point inputs, it is the same as the
 |          input dtype.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      m : np.matrix
 |      
 |      See Also
 |      --------
 |      np.matrix.mean : NumPy's implementation of 'mean' for matrices
 |  
 |  reshape(self, *args, **kwargs)
 |      reshape(self, shape, order='C', copy=False)
 |      
 |      Gives a new shape to a sparse matrix without changing its data.
 |      
 |      Parameters
 |      ----------
 |      shape : length-2 tuple of ints
 |          The new shape should be compatible with the original shape.
 |      order : {'C', 'F'}, optional
 |          Read the elements using this index order. 'C' means to read and
 |          write the elements using C-like index order; e.g. read entire first
 |          row, then second row, etc. 'F' means to read and write the elements
 |          using Fortran-like index order; e.g. read entire first column, then
 |          second column, etc.
 |      copy : bool, optional
 |          Indicates whether or not attributes of self should be copied
 |          whenever possible. The degree to which attributes are copied varies
 |          depending on the type of sparse matrix being used.
 |      
 |      Returns
 |      -------
 |      reshaped_matrix : sparse matrix
 |          A sparse matrix with the given `shape`, not necessarily of the same
 |          format as the current object.
 |      
 |      See Also
 |      --------
 |      np.matrix.reshape : NumPy's implementation of 'reshape' for matrices
 |  
 |  set_shape(self, shape)
 |      See `reshape`.
 |  
 |  setdiag(self, values, k=0)
 |      Set diagonal or off-diagonal elements of the array.
 |      
 |      Parameters
 |      ----------
 |      values : array_like
 |          New values of the diagonal elements.
 |      
 |          Values may have any length.  If the diagonal is longer than values,
 |          then the remaining diagonal entries will not be set.  If values if
 |          longer than the diagonal, then the remaining values are ignored.
 |      
 |          If a scalar value is given, all of the diagonal is set to it.
 |      
 |      k : int, optional
 |          Which off-diagonal to set, corresponding to elements a[i,i+k].
 |          Default: 0 (the main diagonal).
 |  
 |  tobsr(self, blocksize=None, copy=False)
 |      Convert this matrix to Block Sparse Row format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant bsr_matrix.
 |      
 |      When blocksize=(R, C) is provided, it will be used for construction of
 |      the bsr_matrix.
 |  
 |  todense(self, order=None, out=None)
 |      Return a dense matrix representation of this matrix.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F'}, optional
 |          Whether to store multi-dimensional data in C (row-major)
 |          or Fortran (column-major) order in memory. The default
 |          is 'None', indicating the NumPy default of C-ordered.
 |          Cannot be specified in conjunction with the `out`
 |          argument.
 |      
 |      out : ndarray, 2-dimensional, optional
 |          If specified, uses this array (or `numpy.matrix`) as the
 |          output buffer instead of allocating a new array to
 |          return. The provided array must have the same shape and
 |          dtype as the sparse matrix on which you are calling the
 |          method.
 |      
 |      Returns
 |      -------
 |      arr : numpy.matrix, 2-dimensional
 |          A NumPy matrix object with the same shape and containing
 |          the same data represented by the sparse matrix, with the
 |          requested memory order. If `out` was passed and was an
 |          array (rather than a `numpy.matrix`), it will be filled
 |          with the appropriate values and returned wrapped in a
 |          `numpy.matrix` object that shares the same memory.
 |  
 |  todia(self, copy=False)
 |      Convert this matrix to sparse DIAgonal format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dia_matrix.
 |  
 |  todok(self, copy=False)
 |      Convert this matrix to Dictionary Of Keys format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dok_matrix.
 |  
 |  tolil(self, copy=False)
 |      Convert this matrix to LInked List format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant lil_matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.base.spmatrix:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  nnz
 |      Number of stored values, including explicit zeros.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  shape
 |      Get shape of a matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.sparse.base.spmatrix:
 |  
 |  __array_priority__ = 10.1
 |  
 |  ndim = 2
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._minmax_mixin:
 |  
 |  argmax(self, axis=None, out=None)
 |      Return indices of maximum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several maximum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmax is computed. If None (default), index
 |          of the maximum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      ind : np.matrix or int
 |          Indices of maximum elements. If matrix, its size along `axis` is 1.
 |  
 |  argmin(self, axis=None, out=None)
 |      Return indices of minimum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several minimum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmin is computed. If None (default), index
 |          of the minimum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |       ind : np.matrix or int
 |          Indices of minimum elements. If matrix, its size along `axis` is 1.
 |  
 |  max(self, axis=None, out=None)
 |      Return the maximum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the maximum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amax : coo_matrix or scalar
 |          Maximum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      min : The minimum value of a sparse matrix along a given axis.
 |      np.matrix.max : NumPy's implementation of 'max' for matrices
 |  
 |  min(self, axis=None, out=None)
 |      Return the minimum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the minimum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amin : coo_matrix or scalar
 |          Minimum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      max : The maximum value of a sparse matrix along a given axis.
 |      np.matrix.min : NumPy's implementation of 'min' for matrices
",class,"('(self, arg1, shape=None, dtype=None, copy=False)',)",scipy,1.1.0,scipy.integrate._bvp.csc_matrix,integrate._bvp,csc_matrix,"Python Library Documentation: class csc_matrix in module scipy.sparse.csc

class csc_matrix(scipy.sparse.compressed._cs_matrix, scipy.sparse.sputils.IndexMixin)
 |  Compressed Sparse Column matrix
 |  
 |  This can be instantiated in several ways:
 |  
 |      csc_matrix(D)
 |          with a dense matrix or rank-2 ndarray D
 |  
 |      csc_matrix(S)
 |          with another sparse matrix S (equivalent to S.tocsc())
 |  
 |      csc_matrix((M, N), [dtype])
 |          to construct an empty matrix with shape (M, N)
 |          dtype is optional, defaulting to dtype='d'.
 |  
 |      csc_matrix((data, (row_ind, col_ind)), [shape=(M, N)])
 |          where ``data``, ``row_ind`` and ``col_ind`` satisfy the
 |          relationship ``a[row_ind[k], col_ind[k]] = data[k]``.
 |  
 |      csc_matrix((data, indices, indptr), [shape=(M, N)])
 |          is the standard CSC representation where the row indices for
 |          column i are stored in ``indices[indptr[i]:indptr[i+1]]``
 |          and their corresponding values are stored in
 |          ``data[indptr[i]:indptr[i+1]]``.  If the shape parameter is
 |          not supplied, the matrix dimensions are inferred from
 |          the index arrays.
 |  
 |  Attributes
 |  ----------
 |  dtype : dtype
 |      Data type of the matrix
 |  shape : 2-tuple
 |      Shape of the matrix
 |  ndim : int
 |      Number of dimensions (this is always 2)
 |  nnz
 |      Number of nonzero elements
 |  data
 |      Data array of the matrix
 |  indices
 |      CSC format index array
 |  indptr
 |      CSC format index pointer array
 |  has_sorted_indices
 |      Whether indices are sorted
 |  
 |  Notes
 |  -----
 |  
 |  Sparse matrices can be used in arithmetic operations: they support
 |  addition, subtraction, multiplication, division, and matrix power.
 |  
 |  Advantages of the CSC format
 |      - efficient arithmetic operations CSC + CSC, CSC * CSC, etc.
 |      - efficient column slicing
 |      - fast matrix vector products (CSR, BSR may be faster)
 |  
 |  Disadvantages of the CSC format
 |    - slow row slicing operations (consider CSR)
 |    - changes to the sparsity structure are expensive (consider LIL or DOK)
 |  
 |  
 |  Examples
 |  --------
 |  
 |  >>> import numpy as np
 |  >>> from scipy.sparse import csc_matrix
 |  >>> csc_matrix((3, 4), dtype=np.int8).toarray()
 |  array([[0, 0, 0, 0],
 |         [0, 0, 0, 0],
 |         [0, 0, 0, 0]], dtype=int8)
 |  
 |  >>> row = np.array([0, 2, 2, 0, 1, 2])
 |  >>> col = np.array([0, 0, 1, 2, 2, 2])
 |  >>> data = np.array([1, 2, 3, 4, 5, 6])
 |  >>> csc_matrix((data, (row, col)), shape=(3, 3)).toarray()
 |  array([[1, 0, 4],
 |         [0, 0, 5],
 |         [2, 3, 6]])
 |  
 |  >>> indptr = np.array([0, 2, 3, 6])
 |  >>> indices = np.array([0, 2, 2, 0, 1, 2])
 |  >>> data = np.array([1, 2, 3, 4, 5, 6])
 |  >>> csc_matrix((data, indices, indptr), shape=(3, 3)).toarray()
 |  array([[1, 0, 4],
 |         [0, 0, 5],
 |         [2, 3, 6]])
 |  
 |  Method resolution order:
 |      csc_matrix
 |      scipy.sparse.compressed._cs_matrix
 |      scipy.sparse.data._data_matrix
 |      scipy.sparse.base.spmatrix
 |      scipy.sparse.data._minmax_mixin
 |      scipy.sparse.sputils.IndexMixin
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __getitem__(self, key)
 |  
 |  __iter__(self)
 |  
 |  getcol(self, i)
 |      Returns a copy of column i of the matrix, as a (m x 1)
 |      CSC matrix (column vector).
 |  
 |  getrow(self, i)
 |      Returns a copy of row i of the matrix, as a (1 x n)
 |      CSR matrix (row vector).
 |  
 |  nonzero(self)
 |      nonzero indices
 |      
 |      Returns a tuple of arrays (row,col) containing the indices
 |      of the non-zero elements of the matrix.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1,2,0],[0,0,3],[4,0,5]])
 |      >>> A.nonzero()
 |      (array([0, 0, 1, 2, 2]), array([0, 1, 2, 0, 2]))
 |  
 |  tocsc(self, copy=False)
 |      Convert this matrix to Compressed Sparse Column format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant csc_matrix.
 |  
 |  tocsr(self, copy=False)
 |      Convert this matrix to Compressed Sparse Row format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant csr_matrix.
 |  
 |  transpose(self, axes=None, copy=False)
 |      Reverses the dimensions of the sparse matrix.
 |      
 |      Parameters
 |      ----------
 |      axes : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value.
 |      copy : bool, optional
 |          Indicates whether or not attributes of `self` should be
 |          copied whenever possible. The degree to which attributes
 |          are copied varies depending on the type of sparse matrix
 |          being used.
 |      
 |      Returns
 |      -------
 |      p : `self` with the dimensions reversed.
 |      
 |      See Also
 |      --------
 |      np.matrix.transpose : NumPy's implementation of 'transpose'
 |                            for matrices
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  format = 'csc'
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.compressed._cs_matrix:
 |  
 |  __eq__(self, other)
 |      Return self==value.
 |  
 |  __ge__(self, other)
 |      Return self>=value.
 |  
 |  __gt__(self, other)
 |      Return self>value.
 |  
 |  __init__(self, arg1, shape=None, dtype=None, copy=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __le__(self, other)
 |      Return self<=value.
 |  
 |  __lt__(self, other)
 |      Return self<value.
 |  
 |  __ne__(self, other)
 |      Return self!=value.
 |  
 |  __setitem__(self, index, x)
 |  
 |  check_format(self, full_check=True)
 |      check whether the matrix format is valid
 |      
 |      Parameters
 |      ----------
 |      full_check : bool, optional
 |          If `True`, rigorous check, O(N) operations. Otherwise
 |          basic check, O(1) operations (default True).
 |  
 |  diagonal(self, k=0)
 |      Returns the k-th diagonal of the matrix.
 |      
 |      Parameters
 |      ----------
 |      k : int, optional
 |          Which diagonal to set, corresponding to elements a[i, i+k].
 |          Default: 0 (the main diagonal).
 |      
 |          .. versionadded:: 1.0
 |      
 |      See also
 |      --------
 |      numpy.diagonal : Equivalent numpy function.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> A.diagonal()
 |      array([1, 0, 5])
 |      >>> A.diagonal(k=1)
 |      array([2, 3])
 |  
 |  eliminate_zeros(self)
 |      Remove zero entries from the matrix
 |      
 |      This is an *in place* operation
 |  
 |  getnnz(self, axis=None)
 |      Number of stored values, including explicit zeros.
 |      
 |      Parameters
 |      ----------
 |      axis : None, 0, or 1
 |          Select between the number of values across the whole matrix, in
 |          each column, or in each row.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  maximum(self, other)
 |      Element-wise maximum between this and another matrix.
 |  
 |  minimum(self, other)
 |      Element-wise minimum between this and another matrix.
 |  
 |  multiply(self, other)
 |      Point-wise multiplication by another matrix, vector, or
 |      scalar.
 |  
 |  prune(self)
 |      Remove empty space after all non-zero elements.
 |  
 |  resize(self, *shape)
 |      Resize the matrix in-place to dimensions given by ``shape``
 |      
 |      Any elements that lie within the new shape will remain at the same
 |      indices, while non-zero elements lying outside the new shape are
 |      removed.
 |      
 |      Parameters
 |      ----------
 |      shape : (int, int)
 |          number of rows and columns in the new matrix
 |      
 |      Notes
 |      -----
 |      The semantics are not identical to `numpy.ndarray.resize` or
 |      `numpy.resize`.  Here, the same data will be maintained at each index
 |      before and after reshape, if that index is within the new bounds.  In
 |      numpy, resizing maintains contiguity of the array, moving elements
 |      around in the logical matrix but not within a flattened representation.
 |      
 |      We give no guarantees about whether the underlying data attributes
 |      (arrays, etc.) will be modified in place or replaced with new objects.
 |  
 |  sort_indices(self)
 |      Sort the indices of this matrix *in place*
 |  
 |  sorted_indices(self)
 |      Return a copy of this matrix with sorted indices
 |  
 |  sum(self, axis=None, dtype=None, out=None)
 |      Sum the matrix elements over a given axis.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the sum of all the matrix elements, returning a scalar
 |          (i.e. `axis` = `None`).
 |      dtype : dtype, optional
 |          The type of the returned matrix and of the accumulator in which
 |          the elements are summed.  The dtype of `a` is used by default
 |          unless `a` has an integer dtype of less precision than the default
 |          platform integer.  In that case, if `a` is signed then the platform
 |          integer is used while if `a` is unsigned then an unsigned integer
 |          of the same precision as the platform integer is used.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      sum_along_axis : np.matrix
 |          A matrix with the same shape as `self`, with the specified
 |          axis removed.
 |      
 |      See Also
 |      --------
 |      np.matrix.sum : NumPy's implementation of 'sum' for matrices
 |  
 |  sum_duplicates(self)
 |      Eliminate duplicate matrix entries by adding them together
 |      
 |      The is an *in place* operation
 |  
 |  toarray(self, order=None, out=None)
 |      Return a dense ndarray representation of this matrix.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F'}, optional
 |          Whether to store multi-dimensional data in C (row-major)
 |          or Fortran (column-major) order in memory. The default
 |          is 'None', indicating the NumPy default of C-ordered.
 |          Cannot be specified in conjunction with the `out`
 |          argument.
 |      
 |      out : ndarray, 2-dimensional, optional
 |          If specified, uses this array as the output buffer
 |          instead of allocating a new array to return. The provided
 |          array must have the same shape and dtype as the sparse
 |          matrix on which you are calling the method. For most
 |          sparse types, `out` is required to be memory contiguous
 |          (either C or Fortran ordered).
 |      
 |      Returns
 |      -------
 |      arr : ndarray, 2-dimensional
 |          An array with the same shape and containing the same
 |          data represented by the sparse matrix, with the requested
 |          memory order. If `out` was passed, the same object is
 |          returned after being modified in-place to contain the
 |          appropriate values.
 |  
 |  tocoo(self, copy=True)
 |      Convert this matrix to COOrdinate format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant coo_matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.compressed._cs_matrix:
 |  
 |  has_canonical_format
 |      Determine whether the matrix has sorted indices and no duplicates
 |      
 |      Returns
 |          - True: if the above applies
 |          - False: otherwise
 |      
 |      has_canonical_format implies has_sorted_indices, so if the latter flag
 |      is False, so will the former be; if the former is found True, the
 |      latter flag is also set.
 |  
 |  has_sorted_indices
 |      Determine whether the matrix has sorted indices
 |      
 |      Returns
 |          - True: if the indices of the matrix are in sorted order
 |          - False: otherwise
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.sparse.compressed._cs_matrix:
 |  
 |  __hash__ = None
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._data_matrix:
 |  
 |  __abs__(self)
 |  
 |  __imul__(self, other)
 |  
 |  __itruediv__(self, other)
 |  
 |  __neg__(self)
 |  
 |  arcsin(self)
 |      Element-wise arcsin.
 |      
 |      See numpy.arcsin for more information.
 |  
 |  arcsinh(self)
 |      Element-wise arcsinh.
 |      
 |      See numpy.arcsinh for more information.
 |  
 |  arctan(self)
 |      Element-wise arctan.
 |      
 |      See numpy.arctan for more information.
 |  
 |  arctanh(self)
 |      Element-wise arctanh.
 |      
 |      See numpy.arctanh for more information.
 |  
 |  astype(self, dtype, casting='unsafe', copy=True)
 |      Cast the matrix elements to a specified type.
 |      
 |      Parameters
 |      ----------
 |      dtype : string or numpy dtype
 |          Typecode or data-type to which to cast the data.
 |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
 |          Controls what kind of data casting may occur.
 |          Defaults to 'unsafe' for backwards compatibility.
 |          'no' means the data types should not be cast at all.
 |          'equiv' means only byte-order changes are allowed.
 |          'safe' means only casts which can preserve values are allowed.
 |          'same_kind' means only safe casts or casts within a kind,
 |          like float64 to float32, are allowed.
 |          'unsafe' means any data conversions may be done.
 |      copy : bool, optional
 |          If `copy` is `False`, the result might share some memory with this
 |          matrix. If `copy` is `True`, it is guaranteed that the result and
 |          this matrix do not share any memory.
 |  
 |  ceil(self)
 |      Element-wise ceil.
 |      
 |      See numpy.ceil for more information.
 |  
 |  conj(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  copy(self)
 |      Returns a copy of this matrix.
 |      
 |      No data/indices will be shared between the returned value and current
 |      matrix.
 |  
 |  count_nonzero(self)
 |      Number of non-zero entries, equivalent to
 |      
 |      np.count_nonzero(a.toarray())
 |      
 |      Unlike getnnz() and the nnz property, which return the number of stored
 |      entries (the length of the data attribute), this method counts the
 |      actual number of non-zero entries in data.
 |  
 |  deg2rad(self)
 |      Element-wise deg2rad.
 |      
 |      See numpy.deg2rad for more information.
 |  
 |  expm1(self)
 |      Element-wise expm1.
 |      
 |      See numpy.expm1 for more information.
 |  
 |  floor(self)
 |      Element-wise floor.
 |      
 |      See numpy.floor for more information.
 |  
 |  log1p(self)
 |      Element-wise log1p.
 |      
 |      See numpy.log1p for more information.
 |  
 |  power(self, n, dtype=None)
 |      This function performs element-wise power.
 |      
 |      Parameters
 |      ----------
 |      n : n is a scalar
 |      
 |      dtype : If dtype is not specified, the current dtype will be preserved.
 |  
 |  rad2deg(self)
 |      Element-wise rad2deg.
 |      
 |      See numpy.rad2deg for more information.
 |  
 |  rint(self)
 |      Element-wise rint.
 |      
 |      See numpy.rint for more information.
 |  
 |  sign(self)
 |      Element-wise sign.
 |      
 |      See numpy.sign for more information.
 |  
 |  sin(self)
 |      Element-wise sin.
 |      
 |      See numpy.sin for more information.
 |  
 |  sinh(self)
 |      Element-wise sinh.
 |      
 |      See numpy.sinh for more information.
 |  
 |  sqrt(self)
 |      Element-wise sqrt.
 |      
 |      See numpy.sqrt for more information.
 |  
 |  tan(self)
 |      Element-wise tan.
 |      
 |      See numpy.tan for more information.
 |  
 |  tanh(self)
 |      Element-wise tanh.
 |      
 |      See numpy.tanh for more information.
 |  
 |  trunc(self)
 |      Element-wise trunc.
 |      
 |      See numpy.trunc for more information.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.data._data_matrix:
 |  
 |  dtype
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.base.spmatrix:
 |  
 |  __add__(self, other)
 |  
 |  __bool__(self)
 |  
 |  __div__(self, other)
 |  
 |  __getattr__(self, attr)
 |  
 |  __iadd__(self, other)
 |  
 |  __idiv__(self, other)
 |  
 |  __isub__(self, other)
 |  
 |  __len__(self)
 |      # What should len(sparse) return? For consistency with dense matrices,
 |      # perhaps it should be the number of rows?  But for some uses the number of
 |      # non-zeros is more important.  For now, raise an exception!
 |  
 |  __matmul__(self, other)
 |  
 |  __mul__(self, other)
 |      interpret other and call one of the following
 |      
 |      self._mul_scalar()
 |      self._mul_vector()
 |      self._mul_multivector()
 |      self._mul_sparse_matrix()
 |  
 |  __nonzero__ = __bool__(self)
 |  
 |  __pow__(self, other)
 |  
 |  __radd__(self, other)
 |  
 |  __rdiv__(self, other)
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __rmatmul__(self, other)
 |  
 |  __rmul__(self, other)
 |  
 |  __rsub__(self, other)
 |  
 |  __rtruediv__(self, other)
 |  
 |  __str__(self)
 |      Return str(self).
 |  
 |  __sub__(self, other)
 |  
 |  __truediv__(self, other)
 |  
 |  asformat(self, format, copy=False)
 |      Return this matrix in the passed sparse format.
 |      
 |      Parameters
 |      ----------
 |      format : {str, None}
 |          The desired sparse matrix format (""csr"", ""csc"", ""lil"", ""dok"", ...)
 |          or None for no conversion.
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : This matrix in the passed sparse format.
 |  
 |  asfptype(self)
 |      Upcast matrix to a floating point format (if necessary)
 |  
 |  conjugate(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  dot(self, other)
 |      Ordinary dot product
 |      
 |      Examples
 |      --------
 |      >>> import numpy as np
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> v = np.array([1, 0, -1])
 |      >>> A.dot(v)
 |      array([ 1, -3, -1], dtype=int64)
 |  
 |  getH(self)
 |      Return the Hermitian transpose of this matrix.
 |      
 |      See Also
 |      --------
 |      np.matrix.getH : NumPy's implementation of `getH` for matrices
 |  
 |  get_shape(self)
 |      Get shape of a matrix.
 |  
 |  getformat(self)
 |      Format of a matrix representation as a string.
 |  
 |  getmaxprint(self)
 |      Maximum number of elements to display when printed.
 |  
 |  mean(self, axis=None, dtype=None, out=None)
 |      Compute the arithmetic mean along the specified axis.
 |      
 |      Returns the average of the matrix elements. The average is taken
 |      over all elements in the matrix by default, otherwise over the
 |      specified axis. `float64` intermediate and return values are used
 |      for integer inputs.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the mean is computed. The default is to compute
 |          the mean of all elements in the matrix (i.e. `axis` = `None`).
 |      dtype : data-type, optional
 |          Type to use in computing the mean. For integer inputs, the default
 |          is `float64`; for floating point inputs, it is the same as the
 |          input dtype.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      m : np.matrix
 |      
 |      See Also
 |      --------
 |      np.matrix.mean : NumPy's implementation of 'mean' for matrices
 |  
 |  reshape(self, *args, **kwargs)
 |      reshape(self, shape, order='C', copy=False)
 |      
 |      Gives a new shape to a sparse matrix without changing its data.
 |      
 |      Parameters
 |      ----------
 |      shape : length-2 tuple of ints
 |          The new shape should be compatible with the original shape.
 |      order : {'C', 'F'}, optional
 |          Read the elements using this index order. 'C' means to read and
 |          write the elements using C-like index order; e.g. read entire first
 |          row, then second row, etc. 'F' means to read and write the elements
 |          using Fortran-like index order; e.g. read entire first column, then
 |          second column, etc.
 |      copy : bool, optional
 |          Indicates whether or not attributes of self should be copied
 |          whenever possible. The degree to which attributes are copied varies
 |          depending on the type of sparse matrix being used.
 |      
 |      Returns
 |      -------
 |      reshaped_matrix : sparse matrix
 |          A sparse matrix with the given `shape`, not necessarily of the same
 |          format as the current object.
 |      
 |      See Also
 |      --------
 |      np.matrix.reshape : NumPy's implementation of 'reshape' for matrices
 |  
 |  set_shape(self, shape)
 |      See `reshape`.
 |  
 |  setdiag(self, values, k=0)
 |      Set diagonal or off-diagonal elements of the array.
 |      
 |      Parameters
 |      ----------
 |      values : array_like
 |          New values of the diagonal elements.
 |      
 |          Values may have any length.  If the diagonal is longer than values,
 |          then the remaining diagonal entries will not be set.  If values if
 |          longer than the diagonal, then the remaining values are ignored.
 |      
 |          If a scalar value is given, all of the diagonal is set to it.
 |      
 |      k : int, optional
 |          Which off-diagonal to set, corresponding to elements a[i,i+k].
 |          Default: 0 (the main diagonal).
 |  
 |  tobsr(self, blocksize=None, copy=False)
 |      Convert this matrix to Block Sparse Row format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant bsr_matrix.
 |      
 |      When blocksize=(R, C) is provided, it will be used for construction of
 |      the bsr_matrix.
 |  
 |  todense(self, order=None, out=None)
 |      Return a dense matrix representation of this matrix.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F'}, optional
 |          Whether to store multi-dimensional data in C (row-major)
 |          or Fortran (column-major) order in memory. The default
 |          is 'None', indicating the NumPy default of C-ordered.
 |          Cannot be specified in conjunction with the `out`
 |          argument.
 |      
 |      out : ndarray, 2-dimensional, optional
 |          If specified, uses this array (or `numpy.matrix`) as the
 |          output buffer instead of allocating a new array to
 |          return. The provided array must have the same shape and
 |          dtype as the sparse matrix on which you are calling the
 |          method.
 |      
 |      Returns
 |      -------
 |      arr : numpy.matrix, 2-dimensional
 |          A NumPy matrix object with the same shape and containing
 |          the same data represented by the sparse matrix, with the
 |          requested memory order. If `out` was passed and was an
 |          array (rather than a `numpy.matrix`), it will be filled
 |          with the appropriate values and returned wrapped in a
 |          `numpy.matrix` object that shares the same memory.
 |  
 |  todia(self, copy=False)
 |      Convert this matrix to sparse DIAgonal format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dia_matrix.
 |  
 |  todok(self, copy=False)
 |      Convert this matrix to Dictionary Of Keys format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dok_matrix.
 |  
 |  tolil(self, copy=False)
 |      Convert this matrix to LInked List format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant lil_matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.base.spmatrix:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  nnz
 |      Number of stored values, including explicit zeros.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  shape
 |      Get shape of a matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.sparse.base.spmatrix:
 |  
 |  __array_priority__ = 10.1
 |  
 |  ndim = 2
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._minmax_mixin:
 |  
 |  argmax(self, axis=None, out=None)
 |      Return indices of maximum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several maximum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmax is computed. If None (default), index
 |          of the maximum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      ind : np.matrix or int
 |          Indices of maximum elements. If matrix, its size along `axis` is 1.
 |  
 |  argmin(self, axis=None, out=None)
 |      Return indices of minimum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several minimum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmin is computed. If None (default), index
 |          of the minimum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |       ind : np.matrix or int
 |          Indices of minimum elements. If matrix, its size along `axis` is 1.
 |  
 |  max(self, axis=None, out=None)
 |      Return the maximum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the maximum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amax : coo_matrix or scalar
 |          Maximum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      min : The minimum value of a sparse matrix along a given axis.
 |      np.matrix.max : NumPy's implementation of 'max' for matrices
 |  
 |  min(self, axis=None, out=None)
 |      Return the minimum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the minimum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amin : coo_matrix or scalar
 |          Minimum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      max : The maximum value of a sparse matrix along a given axis.
 |      np.matrix.min : NumPy's implementation of 'min' for matrices
",class,"('self', 'arg1', 'shape', 'dtype', 'copy')","(nan, nan, None, None, False)","(nan, nan, 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, arg1, shape=None, dtype=None, copy=False)',)"
scipy,1.1.0,scipy.integrate._bvp.estimate_bc_jac,integrate._bvp,estimate_bc_jac,"Python Library Documentation: function estimate_bc_jac in module scipy.integrate._bvp

estimate_bc_jac(bc, ya, yb, p, bc0=None)
    Estimate derivatives of boundary conditions with forward differences.
    
    Returns
    -------
    dbc_dya : ndarray, shape (n + k, n)
        Derivatives with respect to ya. An element (i, j) corresponds to
        d bc_i / d ya_j.
    dbc_dyb : ndarray, shape (n + k, n)
        Derivatives with respect to yb. An element (i, j) corresponds to
        d bc_i / d ya_j.
    dbc_dp : ndarray with shape (n + k, k) or None
        Derivatives with respect to p. An element (i, j) corresponds to
        d bc_i / d p_j. If `p` is empty, None is returned.
",function,"('(bc, ya, yb, p, bc0=None)',)",scipy,1.1.0,scipy.integrate._bvp.estimate_bc_jac,integrate._bvp,estimate_bc_jac,"Python Library Documentation: function estimate_bc_jac in module scipy.integrate._bvp

estimate_bc_jac(bc, ya, yb, p, bc0=None)
    Estimate derivatives of boundary conditions with forward differences.
    
    Returns
    -------
    dbc_dya : ndarray, shape (n + k, n)
        Derivatives with respect to ya. An element (i, j) corresponds to
        d bc_i / d ya_j.
    dbc_dyb : ndarray, shape (n + k, n)
        Derivatives with respect to yb. An element (i, j) corresponds to
        d bc_i / d ya_j.
    dbc_dp : ndarray with shape (n + k, k) or None
        Derivatives with respect to p. An element (i, j) corresponds to
        d bc_i / d p_j. If `p` is empty, None is returned.
",function,"('bc', 'ya', 'yb', 'p', 'bc0')","(nan, nan, nan, nan, None)","(nan, nan, nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(bc, ya, yb, p, bc0=None)',)"
scipy,1.1.0,scipy.integrate._bvp.estimate_fun_jac,integrate._bvp,estimate_fun_jac,"Python Library Documentation: function estimate_fun_jac in module scipy.integrate._bvp

estimate_fun_jac(fun, x, y, p, f0=None)
    Estimate derivatives of an ODE system rhs with forward differences.
    
    Returns
    -------
    df_dy : ndarray, shape (n, n, m)
        Derivatives with respect to y. An element (i, j, q) corresponds to
        d f_i(x_q, y_q) / d (y_q)_j.
    df_dp : ndarray with shape (n, k, m) or None
        Derivatives with respect to p. An element (i, j, q) corresponds to
        d f_i(x_q, y_q, p) / d p_j. If `p` is empty, None is returned.
",function,"('(fun, x, y, p, f0=None)',)",scipy,1.1.0,scipy.integrate._bvp.estimate_fun_jac,integrate._bvp,estimate_fun_jac,"Python Library Documentation: function estimate_fun_jac in module scipy.integrate._bvp

estimate_fun_jac(fun, x, y, p, f0=None)
    Estimate derivatives of an ODE system rhs with forward differences.
    
    Returns
    -------
    df_dy : ndarray, shape (n, n, m)
        Derivatives with respect to y. An element (i, j, q) corresponds to
        d f_i(x_q, y_q) / d (y_q)_j.
    df_dp : ndarray with shape (n, k, m) or None
        Derivatives with respect to p. An element (i, j, q) corresponds to
        d f_i(x_q, y_q, p) / d p_j. If `p` is empty, None is returned.
",function,"('fun', 'x', 'y', 'p', 'f0')","(nan, nan, nan, nan, None)","(nan, nan, nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(fun, x, y, p, f0=None)',)"
scipy,1.1.0,scipy.integrate._bvp.estimate_rms_residuals,integrate._bvp,estimate_rms_residuals,"Python Library Documentation: function estimate_rms_residuals in module scipy.integrate._bvp

estimate_rms_residuals(fun, sol, x, h, p, r_middle, f_middle)
    Estimate rms values of collocation residuals using Lobatto quadrature.
    
    The residuals are defined as the difference between the derivatives of
    our solution and rhs of the ODE system. We use relative residuals, i.e.
    normalized by 1 + np.abs(f). RMS values are computed as sqrt from the
    normalized integrals of the squared relative residuals over each interval.
    Integrals are estimated using 5-point Lobatto quadrature [1]_, we use the
    fact that residuals at the mesh nodes are identically zero.
    
    In [2] they don't normalize integrals by interval lengths, which gives
    a higher rate of convergence of the residuals by the factor of h**0.5.
    I chose to do such normalization for an ease of interpretation of return
    values as RMS estimates.
    
    Returns
    -------
    rms_res : ndarray, shape (m - 1,)
        Estimated rms values of the relative residuals over each interval.
    
    References
    ----------
    .. [1] http://mathworld.wolfram.com/LobattoQuadrature.html
    .. [2] J. Kierzenka, L. F. Shampine, ""A BVP Solver Based on Residual
       Control and the Maltab PSE"", ACM Trans. Math. Softw., Vol. 27,
       Number 3, pp. 299-316, 2001.
",function,"('(fun, sol, x, h, p, r_middle, f_middle)',)",scipy,1.1.0,scipy.integrate._bvp.estimate_rms_residuals,integrate._bvp,estimate_rms_residuals,"Python Library Documentation: function estimate_rms_residuals in module scipy.integrate._bvp

estimate_rms_residuals(fun, sol, x, h, p, r_middle, f_middle)
    Estimate rms values of collocation residuals using Lobatto quadrature.
    
    The residuals are defined as the difference between the derivatives of
    our solution and rhs of the ODE system. We use relative residuals, i.e.
    normalized by 1 + np.abs(f). RMS values are computed as sqrt from the
    normalized integrals of the squared relative residuals over each interval.
    Integrals are estimated using 5-point Lobatto quadrature [1]_, we use the
    fact that residuals at the mesh nodes are identically zero.
    
    In [2] they don't normalize integrals by interval lengths, which gives
    a higher rate of convergence of the residuals by the factor of h**0.5.
    I chose to do such normalization for an ease of interpretation of return
    values as RMS estimates.
    
    Returns
    -------
    rms_res : ndarray, shape (m - 1,)
        Estimated rms values of the relative residuals over each interval.
    
    References
    ----------
    .. [1] http://mathworld.wolfram.com/LobattoQuadrature.html
    .. [2] J. Kierzenka, L. F. Shampine, ""A BVP Solver Based on Residual
       Control and the Maltab PSE"", ACM Trans. Math. Softw., Vol. 27,
       Number 3, pp. 299-316, 2001.
",function,"('fun', 'sol', 'x', 'h', 'p', 'r_middle', 'f_middle')","(nan, nan, nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(fun, sol, x, h, p, r_middle, f_middle)',)"
scipy,1.1.0,scipy.integrate._bvp.modify_mesh,integrate._bvp,modify_mesh,"Python Library Documentation: function modify_mesh in module scipy.integrate._bvp

modify_mesh(x, insert_1, insert_2)
    Insert nodes into a mesh.
    
    Nodes removal logic is not established, its impact on the solver is
    presumably negligible. So only insertion is done in this function.
    
    Parameters
    ----------
    x : ndarray, shape (m,)
        Mesh nodes.
    insert_1 : ndarray
        Intervals to each insert 1 new node in the middle.
    insert_2 : ndarray
        Intervals to each insert 2 new nodes, such that divide an interval
        into 3 equal parts.
    
    Returns
    -------
    x_new : ndarray
        New mesh nodes.
    
    Notes
    -----
    `insert_1` and `insert_2` should not have common values.
",function,"('(x, insert_1, insert_2)',)",scipy,1.1.0,scipy.integrate._bvp.modify_mesh,integrate._bvp,modify_mesh,"Python Library Documentation: function modify_mesh in module scipy.integrate._bvp

modify_mesh(x, insert_1, insert_2)
    Insert nodes into a mesh.
    
    Nodes removal logic is not established, its impact on the solver is
    presumably negligible. So only insertion is done in this function.
    
    Parameters
    ----------
    x : ndarray, shape (m,)
        Mesh nodes.
    insert_1 : ndarray
        Intervals to each insert 1 new node in the middle.
    insert_2 : ndarray
        Intervals to each insert 2 new nodes, such that divide an interval
        into 3 equal parts.
    
    Returns
    -------
    x_new : ndarray
        New mesh nodes.
    
    Notes
    -----
    `insert_1` and `insert_2` should not have common values.
",function,"('x', 'insert_1', 'insert_2')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(x, insert_1, insert_2)',)"
scipy,1.1.0,scipy.integrate._bvp.norm,integrate._bvp,norm,"Python Library Documentation: function norm in module numpy.linalg.linalg

norm(x, ord=None, axis=None, keepdims=False)
    Matrix or vector norm.
    
    This function is able to return one of eight different matrix norms,
    or one of an infinite number of vector norms (described below), depending
    on the value of the ``ord`` parameter.
    
    Parameters
    ----------
    x : array_like
        Input array.  If `axis` is None, `x` must be 1-D or 2-D.
    ord : {non-zero int, inf, -inf, 'fro', 'nuc'}, optional
        Order of the norm (see table under ``Notes``). inf means numpy's
        `inf` object.
    axis : {int, 2-tuple of ints, None}, optional
        If `axis` is an integer, it specifies the axis of `x` along which to
        compute the vector norms.  If `axis` is a 2-tuple, it specifies the
        axes that hold 2-D matrices, and the matrix norms of these matrices
        are computed.  If `axis` is None then either a vector norm (when `x`
        is 1-D) or a matrix norm (when `x` is 2-D) is returned.
    keepdims : bool, optional
        If this is set to True, the axes which are normed over are left in the
        result as dimensions with size one.  With this option the result will
        broadcast correctly against the original `x`.
    
        .. versionadded:: 1.10.0
    
    Returns
    -------
    n : float or ndarray
        Norm of the matrix or vector(s).
    
    Notes
    -----
    For values of ``ord <= 0``, the result is, strictly speaking, not a
    mathematical 'norm', but it may still be useful for various numerical
    purposes.
    
    The following norms can be calculated:
    
    =====  ============================  ==========================
    ord    norm for matrices             norm for vectors
    =====  ============================  ==========================
    None   Frobenius norm                2-norm
    'fro'  Frobenius norm                --
    'nuc'  nuclear norm                  --
    inf    max(sum(abs(x), axis=1))      max(abs(x))
    -inf   min(sum(abs(x), axis=1))      min(abs(x))
    0      --                            sum(x != 0)
    1      max(sum(abs(x), axis=0))      as below
    -1     min(sum(abs(x), axis=0))      as below
    2      2-norm (largest sing. value)  as below
    -2     smallest singular value       as below
    other  --                            sum(abs(x)**ord)**(1./ord)
    =====  ============================  ==========================
    
    The Frobenius norm is given by [1]_:
    
        :math:`||A||_F = [\sum_{i,j} abs(a_{i,j})^2]^{1/2}`
    
    The nuclear norm is the sum of the singular values.
    
    References
    ----------
    .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*,
           Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15
    
    Examples
    --------
    >>> from numpy import linalg as LA
    >>> a = np.arange(9) - 4
    >>> a
    array([-4, -3, -2, -1,  0,  1,  2,  3,  4])
    >>> b = a.reshape((3, 3))
    >>> b
    array([[-4, -3, -2],
           [-1,  0,  1],
           [ 2,  3,  4]])
    
    >>> LA.norm(a)
    7.745966692414834
    >>> LA.norm(b)
    7.745966692414834
    >>> LA.norm(b, 'fro')
    7.745966692414834
    >>> LA.norm(a, np.inf)
    4.0
    >>> LA.norm(b, np.inf)
    9.0
    >>> LA.norm(a, -np.inf)
    0.0
    >>> LA.norm(b, -np.inf)
    2.0
    
    >>> LA.norm(a, 1)
    20.0
    >>> LA.norm(b, 1)
    7.0
    >>> LA.norm(a, -1)
    -4.6566128774142013e-010
    >>> LA.norm(b, -1)
    6.0
    >>> LA.norm(a, 2)
    7.745966692414834
    >>> LA.norm(b, 2)
    7.3484692283495345
    
    >>> LA.norm(a, -2)
    nan
    >>> LA.norm(b, -2)
    1.8570331885190563e-016
    >>> LA.norm(a, 3)
    5.8480354764257312
    >>> LA.norm(a, -3)
    nan
    
    Using the `axis` argument to compute vector norms:
    
    >>> c = np.array([[ 1, 2, 3],
    ...               [-1, 1, 4]])
    >>> LA.norm(c, axis=0)
    array([ 1.41421356,  2.23606798,  5.        ])
    >>> LA.norm(c, axis=1)
    array([ 3.74165739,  4.24264069])
    >>> LA.norm(c, ord=1, axis=1)
    array([ 6.,  6.])
    
    Using the `axis` argument to compute matrix norms:
    
    >>> m = np.arange(8).reshape(2,2,2)
    >>> LA.norm(m, axis=(1,2))
    array([  3.74165739,  11.22497216])
    >>> LA.norm(m[0, :, :]), LA.norm(m[1, :, :])
    (3.7416573867739413, 11.224972160321824)
",function,"('(x, ord=None, axis=None, keepdims=False)',)",scipy,1.1.0,scipy.integrate._bvp.norm,integrate._bvp,norm,"Python Library Documentation: function norm in module numpy.linalg.linalg

norm(x, ord=None, axis=None, keepdims=False)
    Matrix or vector norm.
    
    This function is able to return one of eight different matrix norms,
    or one of an infinite number of vector norms (described below), depending
    on the value of the ``ord`` parameter.
    
    Parameters
    ----------
    x : array_like
        Input array.  If `axis` is None, `x` must be 1-D or 2-D.
    ord : {non-zero int, inf, -inf, 'fro', 'nuc'}, optional
        Order of the norm (see table under ``Notes``). inf means numpy's
        `inf` object.
    axis : {int, 2-tuple of ints, None}, optional
        If `axis` is an integer, it specifies the axis of `x` along which to
        compute the vector norms.  If `axis` is a 2-tuple, it specifies the
        axes that hold 2-D matrices, and the matrix norms of these matrices
        are computed.  If `axis` is None then either a vector norm (when `x`
        is 1-D) or a matrix norm (when `x` is 2-D) is returned.
    keepdims : bool, optional
        If this is set to True, the axes which are normed over are left in the
        result as dimensions with size one.  With this option the result will
        broadcast correctly against the original `x`.
    
        .. versionadded:: 1.10.0
    
    Returns
    -------
    n : float or ndarray
        Norm of the matrix or vector(s).
    
    Notes
    -----
    For values of ``ord <= 0``, the result is, strictly speaking, not a
    mathematical 'norm', but it may still be useful for various numerical
    purposes.
    
    The following norms can be calculated:
    
    =====  ============================  ==========================
    ord    norm for matrices             norm for vectors
    =====  ============================  ==========================
    None   Frobenius norm                2-norm
    'fro'  Frobenius norm                --
    'nuc'  nuclear norm                  --
    inf    max(sum(abs(x), axis=1))      max(abs(x))
    -inf   min(sum(abs(x), axis=1))      min(abs(x))
    0      --                            sum(x != 0)
    1      max(sum(abs(x), axis=0))      as below
    -1     min(sum(abs(x), axis=0))      as below
    2      2-norm (largest sing. value)  as below
    -2     smallest singular value       as below
    other  --                            sum(abs(x)**ord)**(1./ord)
    =====  ============================  ==========================
    
    The Frobenius norm is given by [1]_:
    
        :math:`||A||_F = [\sum_{i,j} abs(a_{i,j})^2]^{1/2}`
    
    The nuclear norm is the sum of the singular values.
    
    References
    ----------
    .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*,
           Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15
    
    Examples
    --------
    >>> from numpy import linalg as LA
    >>> a = np.arange(9) - 4
    >>> a
    array([-4, -3, -2, -1,  0,  1,  2,  3,  4])
    >>> b = a.reshape((3, 3))
    >>> b
    array([[-4, -3, -2],
           [-1,  0,  1],
           [ 2,  3,  4]])
    
    >>> LA.norm(a)
    7.745966692414834
    >>> LA.norm(b)
    7.745966692414834
    >>> LA.norm(b, 'fro')
    7.745966692414834
    >>> LA.norm(a, np.inf)
    4.0
    >>> LA.norm(b, np.inf)
    9.0
    >>> LA.norm(a, -np.inf)
    0.0
    >>> LA.norm(b, -np.inf)
    2.0
    
    >>> LA.norm(a, 1)
    20.0
    >>> LA.norm(b, 1)
    7.0
    >>> LA.norm(a, -1)
    -4.6566128774142013e-010
    >>> LA.norm(b, -1)
    6.0
    >>> LA.norm(a, 2)
    7.745966692414834
    >>> LA.norm(b, 2)
    7.3484692283495345
    
    >>> LA.norm(a, -2)
    nan
    >>> LA.norm(b, -2)
    1.8570331885190563e-016
    >>> LA.norm(a, 3)
    5.8480354764257312
    >>> LA.norm(a, -3)
    nan
    
    Using the `axis` argument to compute vector norms:
    
    >>> c = np.array([[ 1, 2, 3],
    ...               [-1, 1, 4]])
    >>> LA.norm(c, axis=0)
    array([ 1.41421356,  2.23606798,  5.        ])
    >>> LA.norm(c, axis=1)
    array([ 3.74165739,  4.24264069])
    >>> LA.norm(c, ord=1, axis=1)
    array([ 6.,  6.])
    
    Using the `axis` argument to compute matrix norms:
    
    >>> m = np.arange(8).reshape(2,2,2)
    >>> LA.norm(m, axis=(1,2))
    array([  3.74165739,  11.22497216])
    >>> LA.norm(m[0, :, :]), LA.norm(m[1, :, :])
    (3.7416573867739413, 11.224972160321824)
",function,"('x', 'ord', 'axis', 'keepdims')","(nan, None, None, False)","(nan, 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, ord=None, axis=None, keepdims=False)',)"
scipy,1.1.0,scipy.integrate._bvp.pinv,integrate._bvp,pinv,"Python Library Documentation: function pinv in module numpy.linalg.linalg

pinv(a, rcond=1e-15)
    Compute the (Moore-Penrose) pseudo-inverse of a matrix.
    
    Calculate the generalized inverse of a matrix using its
    singular-value decomposition (SVD) and including all
    *large* singular values.
    
    .. versionchanged:: 1.14
       Can now operate on stacks of matrices
    
    Parameters
    ----------
    a : (..., M, N) array_like
        Matrix or stack of matrices to be pseudo-inverted.
    rcond : (...) array_like of float
        Cutoff for small singular values.
        Singular values smaller (in modulus) than
        `rcond` * largest_singular_value (again, in modulus)
        are set to zero. Broadcasts against the stack of matrices
    
    Returns
    -------
    B : (..., N, M) ndarray
        The pseudo-inverse of `a`. If `a` is a `matrix` instance, then so
        is `B`.
    
    Raises
    ------
    LinAlgError
        If the SVD computation does not converge.
    
    Notes
    -----
    The pseudo-inverse of a matrix A, denoted :math:`A^+`, is
    defined as: ""the matrix that 'solves' [the least-squares problem]
    :math:`Ax = b`,"" i.e., if :math:`\bar{x}` is said solution, then
    :math:`A^+` is that matrix such that :math:`\bar{x} = A^+b`.
    
    It can be shown that if :math:`Q_1 \Sigma Q_2^T = A` is the singular
    value decomposition of A, then
    :math:`A^+ = Q_2 \Sigma^+ Q_1^T`, where :math:`Q_{1,2}` are
    orthogonal matrices, :math:`\Sigma` is a diagonal matrix consisting
    of A's so-called singular values, (followed, typically, by
    zeros), and then :math:`\Sigma^+` is simply the diagonal matrix
    consisting of the reciprocals of A's singular values
    (again, followed by zeros). [1]_
    
    References
    ----------
    .. [1] G. Strang, *Linear Algebra and Its Applications*, 2nd Ed., Orlando,
           FL, Academic Press, Inc., 1980, pp. 139-142.
    
    Examples
    --------
    The following example checks that ``a * a+ * a == a`` and
    ``a+ * a * a+ == a+``:
    
    >>> a = np.random.randn(9, 6)
    >>> B = np.linalg.pinv(a)
    >>> np.allclose(a, np.dot(a, np.dot(B, a)))
    True
    >>> np.allclose(B, np.dot(B, np.dot(a, B)))
    True
",function,"('(a, rcond=1e-15)',)",scipy,1.1.0,scipy.integrate._bvp.pinv,integrate._bvp,pinv,"Python Library Documentation: function pinv in module numpy.linalg.linalg

pinv(a, rcond=1e-15)
    Compute the (Moore-Penrose) pseudo-inverse of a matrix.
    
    Calculate the generalized inverse of a matrix using its
    singular-value decomposition (SVD) and including all
    *large* singular values.
    
    .. versionchanged:: 1.14
       Can now operate on stacks of matrices
    
    Parameters
    ----------
    a : (..., M, N) array_like
        Matrix or stack of matrices to be pseudo-inverted.
    rcond : (...) array_like of float
        Cutoff for small singular values.
        Singular values smaller (in modulus) than
        `rcond` * largest_singular_value (again, in modulus)
        are set to zero. Broadcasts against the stack of matrices
    
    Returns
    -------
    B : (..., N, M) ndarray
        The pseudo-inverse of `a`. If `a` is a `matrix` instance, then so
        is `B`.
    
    Raises
    ------
    LinAlgError
        If the SVD computation does not converge.
    
    Notes
    -----
    The pseudo-inverse of a matrix A, denoted :math:`A^+`, is
    defined as: ""the matrix that 'solves' [the least-squares problem]
    :math:`Ax = b`,"" i.e., if :math:`\bar{x}` is said solution, then
    :math:`A^+` is that matrix such that :math:`\bar{x} = A^+b`.
    
    It can be shown that if :math:`Q_1 \Sigma Q_2^T = A` is the singular
    value decomposition of A, then
    :math:`A^+ = Q_2 \Sigma^+ Q_1^T`, where :math:`Q_{1,2}` are
    orthogonal matrices, :math:`\Sigma` is a diagonal matrix consisting
    of A's so-called singular values, (followed, typically, by
    zeros), and then :math:`\Sigma^+` is simply the diagonal matrix
    consisting of the reciprocals of A's singular values
    (again, followed by zeros). [1]_
    
    References
    ----------
    .. [1] G. Strang, *Linear Algebra and Its Applications*, 2nd Ed., Orlando,
           FL, Academic Press, Inc., 1980, pp. 139-142.
    
    Examples
    --------
    The following example checks that ``a * a+ * a == a`` and
    ``a+ * a * a+ == a+``:
    
    >>> a = np.random.randn(9, 6)
    >>> B = np.linalg.pinv(a)
    >>> np.allclose(a, np.dot(a, np.dot(B, a)))
    True
    >>> np.allclose(B, np.dot(B, np.dot(a, B)))
    True
",function,"('a', 'rcond')","(nan, 1e-15)","(nan, 'float')","('arg_info', 'arg_info')","('(a, rcond=1e-15)',)"
scipy,1.1.0,scipy.integrate._bvp.prepare_sys,integrate._bvp,prepare_sys,"Python Library Documentation: function prepare_sys in module scipy.integrate._bvp

prepare_sys(n, m, k, fun, bc, fun_jac, bc_jac, x, h)
    Create the function and the Jacobian for the collocation system.
",function,"('(n, m, k, fun, bc, fun_jac, bc_jac, x, h)',)",scipy,1.1.0,scipy.integrate._bvp.prepare_sys,integrate._bvp,prepare_sys,"Python Library Documentation: function prepare_sys in module scipy.integrate._bvp

prepare_sys(n, m, k, fun, bc, fun_jac, bc_jac, x, h)
    Create the function and the Jacobian for the collocation system.
",function,"('n', 'm', 'k', 'fun', 'bc', 'fun_jac', 'bc_jac', 'x', 'h')","(nan, nan, nan, nan, nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(n, m, k, fun, bc, fun_jac, bc_jac, x, h)',)"
scipy,1.1.0,scipy.integrate._bvp.print_iteration_header,integrate._bvp,print_iteration_header,"Python Library Documentation: function print_iteration_header in module scipy.integrate._bvp

print_iteration_header()
",function,"('()',)",scipy,1.1.0,scipy.integrate._bvp.print_iteration_header,integrate._bvp,print_iteration_header,"Python Library Documentation: function print_iteration_header in module scipy.integrate._bvp

print_iteration_header()
",function,(),(),(),(),"('()',)"
scipy,1.1.0,scipy.integrate._bvp.print_iteration_progress,integrate._bvp,print_iteration_progress,"Python Library Documentation: function print_iteration_progress in module scipy.integrate._bvp

print_iteration_progress(iteration, residual, total_nodes, nodes_added)
",function,"('(iteration, residual, total_nodes, nodes_added)',)",scipy,1.1.0,scipy.integrate._bvp.print_iteration_progress,integrate._bvp,print_iteration_progress,"Python Library Documentation: function print_iteration_progress in module scipy.integrate._bvp

print_iteration_progress(iteration, residual, total_nodes, nodes_added)
",function,"('iteration', 'residual', 'total_nodes', 'nodes_added')","(nan, nan, nan, nan)","(nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(iteration, residual, total_nodes, nodes_added)',)"
scipy,1.1.0,scipy.integrate._bvp.solve_bvp,integrate._bvp,solve_bvp,"Python Library Documentation: function solve_bvp in module scipy.integrate._bvp

solve_bvp(fun, bc, x, y, p=None, S=None, fun_jac=None, bc_jac=None, tol=0.001, max_nodes=1000, verbose=0)
    Solve a boundary-value problem for a system of ODEs.
    
    This function numerically solves a first order system of ODEs subject to
    two-point boundary conditions::
    
        dy / dx = f(x, y, p) + S * y / (x - a), a <= x <= b
        bc(y(a), y(b), p) = 0
    
    Here x is a 1-dimensional independent variable, y(x) is a n-dimensional
    vector-valued function and p is a k-dimensional vector of unknown
    parameters which is to be found along with y(x). For the problem to be
    determined there must be n + k boundary conditions, i.e. bc must be
    (n + k)-dimensional function.
    
    The last singular term in the right-hand side of the system is optional.
    It is defined by an n-by-n matrix S, such that the solution must satisfy
    S y(a) = 0. This condition will be forced during iterations, so it must not
    contradict boundary conditions. See [2]_ for the explanation how this term
    is handled when solving BVPs numerically.
    
    Problems in a complex domain can be solved as well. In this case y and p
    are considered to be complex, and f and bc are assumed to be complex-valued
    functions, but x stays real. Note that f and bc must be complex
    differentiable (satisfy Cauchy-Riemann equations [4]_), otherwise you
    should rewrite your problem for real and imaginary parts separately. To
    solve a problem in a complex domain, pass an initial guess for y with a
    complex data type (see below).
    
    Parameters
    ----------
    fun : callable
        Right-hand side of the system. The calling signature is ``fun(x, y)``,
        or ``fun(x, y, p)`` if parameters are present. All arguments are
        ndarray: ``x`` with shape (m,), ``y`` with shape (n, m), meaning that
        ``y[:, i]`` corresponds to ``x[i]``, and ``p`` with shape (k,). The
        return value must be an array with shape (n, m) and with the same
        layout as ``y``.
    bc : callable
        Function evaluating residuals of the boundary conditions. The calling
        signature is ``bc(ya, yb)``, or ``bc(ya, yb, p)`` if parameters are
        present. All arguments are ndarray: ``ya`` and ``yb`` with shape (n,),
        and ``p`` with shape (k,). The return value must be an array with
        shape (n + k,).
    x : array_like, shape (m,)
        Initial mesh. Must be a strictly increasing sequence of real numbers
        with ``x[0]=a`` and ``x[-1]=b``.
    y : array_like, shape (n, m)
        Initial guess for the function values at the mesh nodes, i-th column
        corresponds to ``x[i]``. For problems in a complex domain pass `y`
        with a complex data type (even if the initial guess is purely real).
    p : array_like with shape (k,) or None, optional
        Initial guess for the unknown parameters. If None (default), it is
        assumed that the problem doesn't depend on any parameters.
    S : array_like with shape (n, n) or None
        Matrix defining the singular term. If None (default), the problem is
        solved without the singular term.
    fun_jac : callable or None, optional
        Function computing derivatives of f with respect to y and p. The
        calling signature is ``fun_jac(x, y)``, or ``fun_jac(x, y, p)`` if
        parameters are present. The return must contain 1 or 2 elements in the
        following order:
    
            * df_dy : array_like with shape (n, n, m) where an element
              (i, j, q) equals to d f_i(x_q, y_q, p) / d (y_q)_j.
            * df_dp : array_like with shape (n, k, m) where an element
              (i, j, q) equals to d f_i(x_q, y_q, p) / d p_j.
    
        Here q numbers nodes at which x and y are defined, whereas i and j
        number vector components. If the problem is solved without unknown
        parameters df_dp should not be returned.
    
        If `fun_jac` is None (default), the derivatives will be estimated
        by the forward finite differences.
    bc_jac : callable or None, optional
        Function computing derivatives of bc with respect to ya, yb and p.
        The calling signature is ``bc_jac(ya, yb)``, or ``bc_jac(ya, yb, p)``
        if parameters are present. The return must contain 2 or 3 elements in
        the following order:
    
            * dbc_dya : array_like with shape (n, n) where an element (i, j)
              equals to d bc_i(ya, yb, p) / d ya_j.
            * dbc_dyb : array_like with shape (n, n) where an element (i, j)
              equals to d bc_i(ya, yb, p) / d yb_j.
            * dbc_dp : array_like with shape (n, k) where an element (i, j)
              equals to d bc_i(ya, yb, p) / d p_j.
    
        If the problem is solved without unknown parameters dbc_dp should not
        be returned.
    
        If `bc_jac` is None (default), the derivatives will be estimated by
        the forward finite differences.
    tol : float, optional
        Desired tolerance of the solution. If we define ``r = y' - f(x, y)``
        where y is the found solution, then the solver tries to achieve on each
        mesh interval ``norm(r / (1 + abs(f)) < tol``, where ``norm`` is
        estimated in a root mean squared sense (using a numerical quadrature
        formula). Default is 1e-3.
    max_nodes : int, optional
        Maximum allowed number of the mesh nodes. If exceeded, the algorithm
        terminates. Default is 1000.
    verbose : {0, 1, 2}, optional
        Level of algorithm's verbosity:
    
            * 0 (default) : work silently.
            * 1 : display a termination report.
            * 2 : display progress during iterations.
    
    Returns
    -------
    Bunch object with the following fields defined:
    sol : PPoly
        Found solution for y as `scipy.interpolate.PPoly` instance, a C1
        continuous cubic spline.
    p : ndarray or None, shape (k,)
        Found parameters. None, if the parameters were not present in the
        problem.
    x : ndarray, shape (m,)
        Nodes of the final mesh.
    y : ndarray, shape (n, m)
        Solution values at the mesh nodes.
    yp : ndarray, shape (n, m)
        Solution derivatives at the mesh nodes.
    rms_residuals : ndarray, shape (m - 1,)
        RMS values of the relative residuals over each mesh interval (see the
        description of `tol` parameter).
    niter : int
        Number of completed iterations.
    status : int
        Reason for algorithm termination:
    
            * 0: The algorithm converged to the desired accuracy.
            * 1: The maximum number of mesh nodes is exceeded.
            * 2: A singular Jacobian encountered when solving the collocation
              system.
    
    message : string
        Verbal description of the termination reason.
    success : bool
        True if the algorithm converged to the desired accuracy (``status=0``).
    
    Notes
    -----
    This function implements a 4-th order collocation algorithm with the
    control of residuals similar to [1]_. A collocation system is solved
    by a damped Newton method with an affine-invariant criterion function as
    described in [3]_.
    
    Note that in [1]_  integral residuals are defined without normalization
    by interval lengths. So their definition is different by a multiplier of
    h**0.5 (h is an interval length) from the definition used here.
    
    .. versionadded:: 0.18.0
    
    References
    ----------
    .. [1] J. Kierzenka, L. F. Shampine, ""A BVP Solver Based on Residual
           Control and the Maltab PSE"", ACM Trans. Math. Softw., Vol. 27,
           Number 3, pp. 299-316, 2001.
    .. [2] L.F. Shampine, P. H. Muir and H. Xu, ""A User-Friendly Fortran BVP
           Solver"".
    .. [3] U. Ascher, R. Mattheij and R. Russell ""Numerical Solution of
           Boundary Value Problems for Ordinary Differential Equations"".
    .. [4] `Cauchy-Riemann equations
            <https://en.wikipedia.org/wiki/Cauchy-Riemann_equations>`_ on
            Wikipedia.
    
    Examples
    --------
    In the first example we solve Bratu's problem::
    
        y'' + k * exp(y) = 0
        y(0) = y(1) = 0
    
    for k = 1.
    
    We rewrite the equation as a first order system and implement its
    right-hand side evaluation::
    
        y1' = y2
        y2' = -exp(y1)
    
    >>> def fun(x, y):
    ...     return np.vstack((y[1], -np.exp(y[0])))
    
    Implement evaluation of the boundary condition residuals:
    
    >>> def bc(ya, yb):
    ...     return np.array([ya[0], yb[0]])
    
    Define the initial mesh with 5 nodes:
    
    >>> x = np.linspace(0, 1, 5)
    
    This problem is known to have two solutions. To obtain both of them we
    use two different initial guesses for y. We denote them by subscripts
    a and b.
    
    >>> y_a = np.zeros((2, x.size))
    >>> y_b = np.zeros((2, x.size))
    >>> y_b[0] = 3
    
    Now we are ready to run the solver.
    
    >>> from scipy.integrate import solve_bvp
    >>> res_a = solve_bvp(fun, bc, x, y_a)
    >>> res_b = solve_bvp(fun, bc, x, y_b)
    
    Let's plot the two found solutions. We take an advantage of having the
    solution in a spline form to produce a smooth plot.
    
    >>> x_plot = np.linspace(0, 1, 100)
    >>> y_plot_a = res_a.sol(x_plot)[0]
    >>> y_plot_b = res_b.sol(x_plot)[0]
    >>> import matplotlib.pyplot as plt
    >>> plt.plot(x_plot, y_plot_a, label='y_a')
    >>> plt.plot(x_plot, y_plot_b, label='y_b')
    >>> plt.legend()
    >>> plt.xlabel(""x"")
    >>> plt.ylabel(""y"")
    >>> plt.show()
    
    We see that the two solutions have similar shape, but differ in scale
    significantly.
    
    In the second example we solve a simple Sturm-Liouville problem::
    
        y'' + k**2 * y = 0
        y(0) = y(1) = 0
    
    It is known that a non-trivial solution y = A * sin(k * x) is possible for
    k = pi * n, where n is an integer. To establish the normalization constant
    A = 1 we add a boundary condition::
    
        y'(0) = k
    
    Again we rewrite our equation as a first order system and implement its
    right-hand side evaluation::
    
        y1' = y2
        y2' = -k**2 * y1
    
    >>> def fun(x, y, p):
    ...     k = p[0]
    ...     return np.vstack((y[1], -k**2 * y[0]))
    
    Note that parameters p are passed as a vector (with one element in our
    case).
    
    Implement the boundary conditions:
    
    >>> def bc(ya, yb, p):
    ...     k = p[0]
    ...     return np.array([ya[0], yb[0], ya[1] - k])
    
    Setup the initial mesh and guess for y. We aim to find the solution for
    k = 2 * pi, to achieve that we set values of y to approximately follow
    sin(2 * pi * x):
    
    >>> x = np.linspace(0, 1, 5)
    >>> y = np.zeros((2, x.size))
    >>> y[0, 1] = 1
    >>> y[0, 3] = -1
    
    Run the solver with 6 as an initial guess for k.
    
    >>> sol = solve_bvp(fun, bc, x, y, p=[6])
    
    We see that the found k is approximately correct:
    
    >>> sol.p[0]
    6.28329460046
    
    And finally plot the solution to see the anticipated sinusoid:
    
    >>> x_plot = np.linspace(0, 1, 100)
    >>> y_plot = sol.sol(x_plot)[0]
    >>> plt.plot(x_plot, y_plot)
    >>> plt.xlabel(""x"")
    >>> plt.ylabel(""y"")
    >>> plt.show()
",function,"('(fun, bc, x, y, p=None, S=None, fun_jac=None, bc_jac=None, tol=0.001, max_nodes=1000, verbose=0)',)",scipy,1.1.0,scipy.integrate._bvp.solve_bvp,integrate._bvp,solve_bvp,"Python Library Documentation: function solve_bvp in module scipy.integrate._bvp

solve_bvp(fun, bc, x, y, p=None, S=None, fun_jac=None, bc_jac=None, tol=0.001, max_nodes=1000, verbose=0)
    Solve a boundary-value problem for a system of ODEs.
    
    This function numerically solves a first order system of ODEs subject to
    two-point boundary conditions::
    
        dy / dx = f(x, y, p) + S * y / (x - a), a <= x <= b
        bc(y(a), y(b), p) = 0
    
    Here x is a 1-dimensional independent variable, y(x) is a n-dimensional
    vector-valued function and p is a k-dimensional vector of unknown
    parameters which is to be found along with y(x). For the problem to be
    determined there must be n + k boundary conditions, i.e. bc must be
    (n + k)-dimensional function.
    
    The last singular term in the right-hand side of the system is optional.
    It is defined by an n-by-n matrix S, such that the solution must satisfy
    S y(a) = 0. This condition will be forced during iterations, so it must not
    contradict boundary conditions. See [2]_ for the explanation how this term
    is handled when solving BVPs numerically.
    
    Problems in a complex domain can be solved as well. In this case y and p
    are considered to be complex, and f and bc are assumed to be complex-valued
    functions, but x stays real. Note that f and bc must be complex
    differentiable (satisfy Cauchy-Riemann equations [4]_), otherwise you
    should rewrite your problem for real and imaginary parts separately. To
    solve a problem in a complex domain, pass an initial guess for y with a
    complex data type (see below).
    
    Parameters
    ----------
    fun : callable
        Right-hand side of the system. The calling signature is ``fun(x, y)``,
        or ``fun(x, y, p)`` if parameters are present. All arguments are
        ndarray: ``x`` with shape (m,), ``y`` with shape (n, m), meaning that
        ``y[:, i]`` corresponds to ``x[i]``, and ``p`` with shape (k,). The
        return value must be an array with shape (n, m) and with the same
        layout as ``y``.
    bc : callable
        Function evaluating residuals of the boundary conditions. The calling
        signature is ``bc(ya, yb)``, or ``bc(ya, yb, p)`` if parameters are
        present. All arguments are ndarray: ``ya`` and ``yb`` with shape (n,),
        and ``p`` with shape (k,). The return value must be an array with
        shape (n + k,).
    x : array_like, shape (m,)
        Initial mesh. Must be a strictly increasing sequence of real numbers
        with ``x[0]=a`` and ``x[-1]=b``.
    y : array_like, shape (n, m)
        Initial guess for the function values at the mesh nodes, i-th column
        corresponds to ``x[i]``. For problems in a complex domain pass `y`
        with a complex data type (even if the initial guess is purely real).
    p : array_like with shape (k,) or None, optional
        Initial guess for the unknown parameters. If None (default), it is
        assumed that the problem doesn't depend on any parameters.
    S : array_like with shape (n, n) or None
        Matrix defining the singular term. If None (default), the problem is
        solved without the singular term.
    fun_jac : callable or None, optional
        Function computing derivatives of f with respect to y and p. The
        calling signature is ``fun_jac(x, y)``, or ``fun_jac(x, y, p)`` if
        parameters are present. The return must contain 1 or 2 elements in the
        following order:
    
            * df_dy : array_like with shape (n, n, m) where an element
              (i, j, q) equals to d f_i(x_q, y_q, p) / d (y_q)_j.
            * df_dp : array_like with shape (n, k, m) where an element
              (i, j, q) equals to d f_i(x_q, y_q, p) / d p_j.
    
        Here q numbers nodes at which x and y are defined, whereas i and j
        number vector components. If the problem is solved without unknown
        parameters df_dp should not be returned.
    
        If `fun_jac` is None (default), the derivatives will be estimated
        by the forward finite differences.
    bc_jac : callable or None, optional
        Function computing derivatives of bc with respect to ya, yb and p.
        The calling signature is ``bc_jac(ya, yb)``, or ``bc_jac(ya, yb, p)``
        if parameters are present. The return must contain 2 or 3 elements in
        the following order:
    
            * dbc_dya : array_like with shape (n, n) where an element (i, j)
              equals to d bc_i(ya, yb, p) / d ya_j.
            * dbc_dyb : array_like with shape (n, n) where an element (i, j)
              equals to d bc_i(ya, yb, p) / d yb_j.
            * dbc_dp : array_like with shape (n, k) where an element (i, j)
              equals to d bc_i(ya, yb, p) / d p_j.
    
        If the problem is solved without unknown parameters dbc_dp should not
        be returned.
    
        If `bc_jac` is None (default), the derivatives will be estimated by
        the forward finite differences.
    tol : float, optional
        Desired tolerance of the solution. If we define ``r = y' - f(x, y)``
        where y is the found solution, then the solver tries to achieve on each
        mesh interval ``norm(r / (1 + abs(f)) < tol``, where ``norm`` is
        estimated in a root mean squared sense (using a numerical quadrature
        formula). Default is 1e-3.
    max_nodes : int, optional
        Maximum allowed number of the mesh nodes. If exceeded, the algorithm
        terminates. Default is 1000.
    verbose : {0, 1, 2}, optional
        Level of algorithm's verbosity:
    
            * 0 (default) : work silently.
            * 1 : display a termination report.
            * 2 : display progress during iterations.
    
    Returns
    -------
    Bunch object with the following fields defined:
    sol : PPoly
        Found solution for y as `scipy.interpolate.PPoly` instance, a C1
        continuous cubic spline.
    p : ndarray or None, shape (k,)
        Found parameters. None, if the parameters were not present in the
        problem.
    x : ndarray, shape (m,)
        Nodes of the final mesh.
    y : ndarray, shape (n, m)
        Solution values at the mesh nodes.
    yp : ndarray, shape (n, m)
        Solution derivatives at the mesh nodes.
    rms_residuals : ndarray, shape (m - 1,)
        RMS values of the relative residuals over each mesh interval (see the
        description of `tol` parameter).
    niter : int
        Number of completed iterations.
    status : int
        Reason for algorithm termination:
    
            * 0: The algorithm converged to the desired accuracy.
            * 1: The maximum number of mesh nodes is exceeded.
            * 2: A singular Jacobian encountered when solving the collocation
              system.
    
    message : string
        Verbal description of the termination reason.
    success : bool
        True if the algorithm converged to the desired accuracy (``status=0``).
    
    Notes
    -----
    This function implements a 4-th order collocation algorithm with the
    control of residuals similar to [1]_. A collocation system is solved
    by a damped Newton method with an affine-invariant criterion function as
    described in [3]_.
    
    Note that in [1]_  integral residuals are defined without normalization
    by interval lengths. So their definition is different by a multiplier of
    h**0.5 (h is an interval length) from the definition used here.
    
    .. versionadded:: 0.18.0
    
    References
    ----------
    .. [1] J. Kierzenka, L. F. Shampine, ""A BVP Solver Based on Residual
           Control and the Maltab PSE"", ACM Trans. Math. Softw., Vol. 27,
           Number 3, pp. 299-316, 2001.
    .. [2] L.F. Shampine, P. H. Muir and H. Xu, ""A User-Friendly Fortran BVP
           Solver"".
    .. [3] U. Ascher, R. Mattheij and R. Russell ""Numerical Solution of
           Boundary Value Problems for Ordinary Differential Equations"".
    .. [4] `Cauchy-Riemann equations
            <https://en.wikipedia.org/wiki/Cauchy-Riemann_equations>`_ on
            Wikipedia.
    
    Examples
    --------
    In the first example we solve Bratu's problem::
    
        y'' + k * exp(y) = 0
        y(0) = y(1) = 0
    
    for k = 1.
    
    We rewrite the equation as a first order system and implement its
    right-hand side evaluation::
    
        y1' = y2
        y2' = -exp(y1)
    
    >>> def fun(x, y):
    ...     return np.vstack((y[1], -np.exp(y[0])))
    
    Implement evaluation of the boundary condition residuals:
    
    >>> def bc(ya, yb):
    ...     return np.array([ya[0], yb[0]])
    
    Define the initial mesh with 5 nodes:
    
    >>> x = np.linspace(0, 1, 5)
    
    This problem is known to have two solutions. To obtain both of them we
    use two different initial guesses for y. We denote them by subscripts
    a and b.
    
    >>> y_a = np.zeros((2, x.size))
    >>> y_b = np.zeros((2, x.size))
    >>> y_b[0] = 3
    
    Now we are ready to run the solver.
    
    >>> from scipy.integrate import solve_bvp
    >>> res_a = solve_bvp(fun, bc, x, y_a)
    >>> res_b = solve_bvp(fun, bc, x, y_b)
    
    Let's plot the two found solutions. We take an advantage of having the
    solution in a spline form to produce a smooth plot.
    
    >>> x_plot = np.linspace(0, 1, 100)
    >>> y_plot_a = res_a.sol(x_plot)[0]
    >>> y_plot_b = res_b.sol(x_plot)[0]
    >>> import matplotlib.pyplot as plt
    >>> plt.plot(x_plot, y_plot_a, label='y_a')
    >>> plt.plot(x_plot, y_plot_b, label='y_b')
    >>> plt.legend()
    >>> plt.xlabel(""x"")
    >>> plt.ylabel(""y"")
    >>> plt.show()
    
    We see that the two solutions have similar shape, but differ in scale
    significantly.
    
    In the second example we solve a simple Sturm-Liouville problem::
    
        y'' + k**2 * y = 0
        y(0) = y(1) = 0
    
    It is known that a non-trivial solution y = A * sin(k * x) is possible for
    k = pi * n, where n is an integer. To establish the normalization constant
    A = 1 we add a boundary condition::
    
        y'(0) = k
    
    Again we rewrite our equation as a first order system and implement its
    right-hand side evaluation::
    
        y1' = y2
        y2' = -k**2 * y1
    
    >>> def fun(x, y, p):
    ...     k = p[0]
    ...     return np.vstack((y[1], -k**2 * y[0]))
    
    Note that parameters p are passed as a vector (with one element in our
    case).
    
    Implement the boundary conditions:
    
    >>> def bc(ya, yb, p):
    ...     k = p[0]
    ...     return np.array([ya[0], yb[0], ya[1] - k])
    
    Setup the initial mesh and guess for y. We aim to find the solution for
    k = 2 * pi, to achieve that we set values of y to approximately follow
    sin(2 * pi * x):
    
    >>> x = np.linspace(0, 1, 5)
    >>> y = np.zeros((2, x.size))
    >>> y[0, 1] = 1
    >>> y[0, 3] = -1
    
    Run the solver with 6 as an initial guess for k.
    
    >>> sol = solve_bvp(fun, bc, x, y, p=[6])
    
    We see that the found k is approximately correct:
    
    >>> sol.p[0]
    6.28329460046
    
    And finally plot the solution to see the anticipated sinusoid:
    
    >>> x_plot = np.linspace(0, 1, 100)
    >>> y_plot = sol.sol(x_plot)[0]
    >>> plt.plot(x_plot, y_plot)
    >>> plt.xlabel(""x"")
    >>> plt.ylabel(""y"")
    >>> plt.show()
",function,"('fun', 'bc', 'x', 'y', 'p', 'S', 'fun_jac', 'bc_jac', 'tol', 'max_nodes', 'verbose')","(nan, nan, nan, nan, None, None, None, None, 0.001, 1000, 0)","(nan, nan, nan, nan, 'NoneType', 'NoneType', 'NoneType', 'NoneType', 'float', 'int', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(fun, bc, x, y, p=None, S=None, fun_jac=None, bc_jac=None, tol=0.001, max_nodes=1000, verbose=0)',)"
scipy,1.1.0,scipy.integrate._bvp.solve_newton,integrate._bvp,solve_newton,"Python Library Documentation: function solve_newton in module scipy.integrate._bvp

solve_newton(n, m, h, col_fun, bc, jac, y, p, B, bvp_tol)
    Solve the nonlinear collocation system by a Newton method.
    
    This is a simple Newton method with a backtracking line search. As
    advised in [1]_, an affine-invariant criterion function F = ||J^-1 r||^2
    is used, where J is the Jacobian matrix at the current iteration and r is
    the vector or collocation residuals (values of the system lhs).
    
    The method alters between full Newton iterations and the fixed-Jacobian
    iterations based
    
    There are other tricks proposed in [1]_, but they are not used as they
    don't seem to improve anything significantly, and even break the
    convergence on some test problems I tried.
    
    All important parameters of the algorithm are defined inside the function.
    
    Parameters
    ----------
    n : int
        Number of equations in the ODE system.
    m : int
        Number of nodes in the mesh.
    h : ndarray, shape (m-1,)
        Mesh intervals.
    col_fun : callable
        Function computing collocation residuals.
    bc : callable
        Function computing boundary condition residuals.
    jac : callable
        Function computing the Jacobian of the whole system (including
        collocation and boundary condition residuals). It is supposed to
        return csc_matrix.
    y : ndarray, shape (n, m)
        Initial guess for the function values at the mesh nodes.
    p : ndarray, shape (k,)
        Initial guess for the unknown parameters.
    B : ndarray with shape (n, n) or None
        Matrix to force the S y(a) = 0 condition for a problems with the
        singular term. If None, the singular term is assumed to be absent.
    bvp_tol : float
        Tolerance to which we want to solve a BVP.
    
    Returns
    -------
    y : ndarray, shape (n, m)
        Final iterate for the function values at the mesh nodes.
    p : ndarray, shape (k,)
        Final iterate for the unknown parameters.
    singular : bool
        True, if the LU decomposition failed because Jacobian turned out
        to be singular.
    
    References
    ----------
    .. [1]  U. Ascher, R. Mattheij and R. Russell ""Numerical Solution of
       Boundary Value Problems for Ordinary Differential Equations""
",function,"('(n, m, h, col_fun, bc, jac, y, p, B, bvp_tol)',)",scipy,1.1.0,scipy.integrate._bvp.solve_newton,integrate._bvp,solve_newton,"Python Library Documentation: function solve_newton in module scipy.integrate._bvp

solve_newton(n, m, h, col_fun, bc, jac, y, p, B, bvp_tol)
    Solve the nonlinear collocation system by a Newton method.
    
    This is a simple Newton method with a backtracking line search. As
    advised in [1]_, an affine-invariant criterion function F = ||J^-1 r||^2
    is used, where J is the Jacobian matrix at the current iteration and r is
    the vector or collocation residuals (values of the system lhs).
    
    The method alters between full Newton iterations and the fixed-Jacobian
    iterations based
    
    There are other tricks proposed in [1]_, but they are not used as they
    don't seem to improve anything significantly, and even break the
    convergence on some test problems I tried.
    
    All important parameters of the algorithm are defined inside the function.
    
    Parameters
    ----------
    n : int
        Number of equations in the ODE system.
    m : int
        Number of nodes in the mesh.
    h : ndarray, shape (m-1,)
        Mesh intervals.
    col_fun : callable
        Function computing collocation residuals.
    bc : callable
        Function computing boundary condition residuals.
    jac : callable
        Function computing the Jacobian of the whole system (including
        collocation and boundary condition residuals). It is supposed to
        return csc_matrix.
    y : ndarray, shape (n, m)
        Initial guess for the function values at the mesh nodes.
    p : ndarray, shape (k,)
        Initial guess for the unknown parameters.
    B : ndarray with shape (n, n) or None
        Matrix to force the S y(a) = 0 condition for a problems with the
        singular term. If None, the singular term is assumed to be absent.
    bvp_tol : float
        Tolerance to which we want to solve a BVP.
    
    Returns
    -------
    y : ndarray, shape (n, m)
        Final iterate for the function values at the mesh nodes.
    p : ndarray, shape (k,)
        Final iterate for the unknown parameters.
    singular : bool
        True, if the LU decomposition failed because Jacobian turned out
        to be singular.
    
    References
    ----------
    .. [1]  U. Ascher, R. Mattheij and R. Russell ""Numerical Solution of
       Boundary Value Problems for Ordinary Differential Equations""
",function,"('n', 'm', 'h', 'col_fun', 'bc', 'jac', 'y', 'p', 'B', 'bvp_tol')","(nan, nan, nan, nan, nan, nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan, nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(n, m, h, col_fun, bc, jac, y, p, B, bvp_tol)',)"
scipy,1.1.0,scipy.integrate._bvp.splu,integrate._bvp,splu,"Python Library Documentation: function splu in module scipy.sparse.linalg.dsolve.linsolve

splu(A, permc_spec=None, diag_pivot_thresh=None, relax=None, panel_size=None, options={})
    Compute the LU decomposition of a sparse, square matrix.
    
    Parameters
    ----------
    A : sparse matrix
        Sparse matrix to factorize. Should be in CSR or CSC format.
    permc_spec : str, optional
        How to permute the columns of the matrix for sparsity preservation.
        (default: 'COLAMD')
    
        - ``NATURAL``: natural ordering.
        - ``MMD_ATA``: minimum degree ordering on the structure of A^T A.
        - ``MMD_AT_PLUS_A``: minimum degree ordering on the structure of A^T+A.
        - ``COLAMD``: approximate minimum degree column ordering
    
    diag_pivot_thresh : float, optional
        Threshold used for a diagonal entry to be an acceptable pivot.
        See SuperLU user's guide for details [1]_
    relax : int, optional
        Expert option for customizing the degree of relaxing supernodes.
        See SuperLU user's guide for details [1]_
    panel_size : int, optional
        Expert option for customizing the panel size.
        See SuperLU user's guide for details [1]_
    options : dict, optional
        Dictionary containing additional expert options to SuperLU.
        See SuperLU user guide [1]_ (section 2.4 on the 'Options' argument)
        for more details. For example, you can specify
        ``options=dict(Equil=False, IterRefine='SINGLE'))``
        to turn equilibration off and perform a single iterative refinement.
    
    Returns
    -------
    invA : scipy.sparse.linalg.SuperLU
        Object, which has a ``solve`` method.
    
    See also
    --------
    spilu : incomplete LU decomposition
    
    Notes
    -----
    This function uses the SuperLU library.
    
    References
    ----------
    .. [1] SuperLU http://crd.lbl.gov/~xiaoye/SuperLU/
    
    Examples
    --------
    >>> from scipy.sparse import csc_matrix
    >>> from scipy.sparse.linalg import splu
    >>> A = csc_matrix([[1., 0., 0.], [5., 0., 2.], [0., -1., 0.]], dtype=float)
    >>> B = splu(A)
    >>> x = np.array([1., 2., 3.], dtype=float)
    >>> B.solve(x)
    array([ 1. , -3. , -1.5])
    >>> A.dot(B.solve(x))
    array([ 1.,  2.,  3.])
    >>> B.solve(A.dot(x))
    array([ 1.,  2.,  3.])
",function,"('(A, permc_spec=None, diag_pivot_thresh=None, relax=None, panel_size=None, options={})',)",scipy,1.1.0,scipy.integrate._bvp.splu,integrate._bvp,splu,"Python Library Documentation: function splu in module scipy.sparse.linalg.dsolve.linsolve

splu(A, permc_spec=None, diag_pivot_thresh=None, relax=None, panel_size=None, options={})
    Compute the LU decomposition of a sparse, square matrix.
    
    Parameters
    ----------
    A : sparse matrix
        Sparse matrix to factorize. Should be in CSR or CSC format.
    permc_spec : str, optional
        How to permute the columns of the matrix for sparsity preservation.
        (default: 'COLAMD')
    
        - ``NATURAL``: natural ordering.
        - ``MMD_ATA``: minimum degree ordering on the structure of A^T A.
        - ``MMD_AT_PLUS_A``: minimum degree ordering on the structure of A^T+A.
        - ``COLAMD``: approximate minimum degree column ordering
    
    diag_pivot_thresh : float, optional
        Threshold used for a diagonal entry to be an acceptable pivot.
        See SuperLU user's guide for details [1]_
    relax : int, optional
        Expert option for customizing the degree of relaxing supernodes.
        See SuperLU user's guide for details [1]_
    panel_size : int, optional
        Expert option for customizing the panel size.
        See SuperLU user's guide for details [1]_
    options : dict, optional
        Dictionary containing additional expert options to SuperLU.
        See SuperLU user guide [1]_ (section 2.4 on the 'Options' argument)
        for more details. For example, you can specify
        ``options=dict(Equil=False, IterRefine='SINGLE'))``
        to turn equilibration off and perform a single iterative refinement.
    
    Returns
    -------
    invA : scipy.sparse.linalg.SuperLU
        Object, which has a ``solve`` method.
    
    See also
    --------
    spilu : incomplete LU decomposition
    
    Notes
    -----
    This function uses the SuperLU library.
    
    References
    ----------
    .. [1] SuperLU http://crd.lbl.gov/~xiaoye/SuperLU/
    
    Examples
    --------
    >>> from scipy.sparse import csc_matrix
    >>> from scipy.sparse.linalg import splu
    >>> A = csc_matrix([[1., 0., 0.], [5., 0., 2.], [0., -1., 0.]], dtype=float)
    >>> B = splu(A)
    >>> x = np.array([1., 2., 3.], dtype=float)
    >>> B.solve(x)
    array([ 1. , -3. , -1.5])
    >>> A.dot(B.solve(x))
    array([ 1.,  2.,  3.])
    >>> B.solve(A.dot(x))
    array([ 1.,  2.,  3.])
",function,"('A', 'permc_spec', 'diag_pivot_thresh', 'relax', 'panel_size', 'options')","(nan, None, None, None, None, {})","(nan, 'NoneType', 'NoneType', 'NoneType', 'NoneType', 'dict')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(A, permc_spec=None, diag_pivot_thresh=None, relax=None, panel_size=None, options={})',)"
scipy,1.1.0,scipy.integrate._bvp.stacked_matmul,integrate._bvp,stacked_matmul,"Python Library Documentation: function stacked_matmul in module scipy.integrate._bvp

stacked_matmul(a, b)
    Stacked matrix multiply: out[i,:,:] = np.dot(a[i,:,:], b[i,:,:]).
    
    In our case a[i, :, :] and b[i, :, :] are always square.
",function,"('(a, b)',)",scipy,1.1.0,scipy.integrate._bvp.stacked_matmul,integrate._bvp,stacked_matmul,"Python Library Documentation: function stacked_matmul in module scipy.integrate._bvp

stacked_matmul(a, b)
    Stacked matrix multiply: out[i,:,:] = np.dot(a[i,:,:], b[i,:,:]).
    
    In our case a[i, :, :] and b[i, :, :] are always square.
",function,"('a', 'b')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(a, b)',)"
scipy,1.1.0,scipy.integrate._bvp.wrap_functions,integrate._bvp,wrap_functions,"Python Library Documentation: function wrap_functions in module scipy.integrate._bvp

wrap_functions(fun, bc, fun_jac, bc_jac, k, a, S, D, dtype)
    Wrap functions for unified usage in the solver.
",function,"('(fun, bc, fun_jac, bc_jac, k, a, S, D, dtype)',)",scipy,1.1.0,scipy.integrate._bvp.wrap_functions,integrate._bvp,wrap_functions,"Python Library Documentation: function wrap_functions in module scipy.integrate._bvp

wrap_functions(fun, bc, fun_jac, bc_jac, k, a, S, D, dtype)
    Wrap functions for unified usage in the solver.
",function,"('fun', 'bc', 'fun_jac', 'bc_jac', 'k', 'a', 'S', 'D', 'dtype')","(nan, nan, nan, nan, nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(fun, bc, fun_jac, bc_jac, k, a, S, D, dtype)',)"
scipy,1.1.0,scipy.integrate._ivp.BDF,integrate._ivp,BDF,"Python Library Documentation: class BDF in module scipy.integrate._ivp.bdf

class BDF(scipy.integrate._ivp.base.OdeSolver)
 |  Implicit method based on backward-differentiation formulas.
 |  
 |  This is a variable order method with the order varying automatically from
 |  1 to 5. The general framework of the BDF algorithm is described in [1]_.
 |  This class implements a quasi-constant step size as explained in [2]_.
 |  The error estimation strategy for the constant-step BDF is derived in [3]_.
 |  An accuracy enhancement using modified formulas (NDF) [2]_ is also implemented.
 |  
 |  Can be applied in the complex domain.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar, and there are two options for the ndarray ``y``:
 |      It can either have shape (n,); then ``fun`` must return array_like with
 |      shape (n,). Alternatively it can have shape (n, k); then ``fun``
 |      must return an array_like with shape (n, k), i.e. each column
 |      corresponds to a single column in ``y``. The choice between the two
 |      options is determined by `vectorized` argument (see below). The
 |      vectorized implementation allows a faster approximation of the Jacobian
 |      by finite differences (required for this solver).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time - the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  max_step : float, optional
 |      Maximum allowed step size. Default is np.inf, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  rtol, atol : float and array_like, optional
 |      Relative and absolute tolerances. The solver keeps the local error
 |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
 |      relative accuracy (number of correct digits). But if a component of `y`
 |      is approximately below `atol`, the error only needs to fall within
 |      the same `atol` threshold, and the number of correct digits is not
 |      guaranteed. If components of y have different scales, it might be
 |      beneficial to set different `atol` values for different components by
 |      passing array_like with shape (n,) for `atol`. Default values are
 |      1e-3 for `rtol` and 1e-6 for `atol`.
 |  jac : {None, array_like, sparse_matrix, callable}, optional
 |      Jacobian matrix of the right-hand side of the system with respect to y,
 |      required by this method. The Jacobian matrix has shape (n, n) and its
 |      element (i, j) is equal to ``d f_i / d y_j``.
 |      There are three ways to define the Jacobian:
 |  
 |          * If array_like or sparse_matrix, the Jacobian is assumed to
 |            be constant.
 |          * If callable, the Jacobian is assumed to depend on both
 |            t and y; it will be called as ``jac(t, y)`` as necessary.
 |            For the 'Radau' and 'BDF' methods, the return value might be a
 |            sparse matrix.
 |          * If None (default), the Jacobian will be approximated by
 |            finite differences.
 |  
 |      It is generally recommended to provide the Jacobian rather than
 |      relying on a finite-difference approximation.
 |  jac_sparsity : {None, array_like, sparse matrix}, optional
 |      Defines a sparsity structure of the Jacobian matrix for a
 |      finite-difference approximation. Its shape must be (n, n). This argument
 |      is ignored if `jac` is not `None`. If the Jacobian has only few non-zero
 |      elements in *each* row, providing the sparsity structure will greatly
 |      speed up the computations [4]_. A zero entry means that a corresponding
 |      element in the Jacobian is always zero. If None (default), the Jacobian
 |      is assumed to be dense.
 |  vectorized : bool, optional
 |      Whether `fun` is implemented in a vectorized fashion. Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number of evaluations of the right-hand side.
 |  njev : int
 |      Number of evaluations of the Jacobian.
 |  nlu : int
 |      Number of LU decompositions.
 |  
 |  References
 |  ----------
 |  .. [1] G. D. Byrne, A. C. Hindmarsh, ""A Polyalgorithm for the Numerical
 |         Solution of Ordinary Differential Equations"", ACM Transactions on
 |         Mathematical Software, Vol. 1, No. 1, pp. 71-96, March 1975.
 |  .. [2] L. F. Shampine, M. W. Reichelt, ""THE MATLAB ODE SUITE"", SIAM J. SCI.
 |         COMPUTE., Vol. 18, No. 1, pp. 1-22, January 1997.
 |  .. [3] E. Hairer, G. Wanner, ""Solving Ordinary Differential Equations I:
 |         Nonstiff Problems"", Sec. III.2.
 |  .. [4] A. Curtis, M. J. D. Powell, and J. Reid, ""On the estimation of
 |         sparse Jacobian matrices"", Journal of the Institute of Mathematics
 |         and its Applications, 13, pp. 117-120, 1974.
 |  
 |  Method resolution order:
 |      BDF
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, jac=None, jac_sparsity=None, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, jac=None, jac_sparsity=None, vectorized=False, **extraneous)',)",scipy,1.1.0,scipy.integrate._ivp.BDF,integrate._ivp,BDF,"Python Library Documentation: class BDF in module scipy.integrate._ivp.bdf

class BDF(scipy.integrate._ivp.base.OdeSolver)
 |  Implicit method based on backward-differentiation formulas.
 |  
 |  This is a variable order method with the order varying automatically from
 |  1 to 5. The general framework of the BDF algorithm is described in [1]_.
 |  This class implements a quasi-constant step size as explained in [2]_.
 |  The error estimation strategy for the constant-step BDF is derived in [3]_.
 |  An accuracy enhancement using modified formulas (NDF) [2]_ is also implemented.
 |  
 |  Can be applied in the complex domain.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar, and there are two options for the ndarray ``y``:
 |      It can either have shape (n,); then ``fun`` must return array_like with
 |      shape (n,). Alternatively it can have shape (n, k); then ``fun``
 |      must return an array_like with shape (n, k), i.e. each column
 |      corresponds to a single column in ``y``. The choice between the two
 |      options is determined by `vectorized` argument (see below). The
 |      vectorized implementation allows a faster approximation of the Jacobian
 |      by finite differences (required for this solver).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time - the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  max_step : float, optional
 |      Maximum allowed step size. Default is np.inf, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  rtol, atol : float and array_like, optional
 |      Relative and absolute tolerances. The solver keeps the local error
 |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
 |      relative accuracy (number of correct digits). But if a component of `y`
 |      is approximately below `atol`, the error only needs to fall within
 |      the same `atol` threshold, and the number of correct digits is not
 |      guaranteed. If components of y have different scales, it might be
 |      beneficial to set different `atol` values for different components by
 |      passing array_like with shape (n,) for `atol`. Default values are
 |      1e-3 for `rtol` and 1e-6 for `atol`.
 |  jac : {None, array_like, sparse_matrix, callable}, optional
 |      Jacobian matrix of the right-hand side of the system with respect to y,
 |      required by this method. The Jacobian matrix has shape (n, n) and its
 |      element (i, j) is equal to ``d f_i / d y_j``.
 |      There are three ways to define the Jacobian:
 |  
 |          * If array_like or sparse_matrix, the Jacobian is assumed to
 |            be constant.
 |          * If callable, the Jacobian is assumed to depend on both
 |            t and y; it will be called as ``jac(t, y)`` as necessary.
 |            For the 'Radau' and 'BDF' methods, the return value might be a
 |            sparse matrix.
 |          * If None (default), the Jacobian will be approximated by
 |            finite differences.
 |  
 |      It is generally recommended to provide the Jacobian rather than
 |      relying on a finite-difference approximation.
 |  jac_sparsity : {None, array_like, sparse matrix}, optional
 |      Defines a sparsity structure of the Jacobian matrix for a
 |      finite-difference approximation. Its shape must be (n, n). This argument
 |      is ignored if `jac` is not `None`. If the Jacobian has only few non-zero
 |      elements in *each* row, providing the sparsity structure will greatly
 |      speed up the computations [4]_. A zero entry means that a corresponding
 |      element in the Jacobian is always zero. If None (default), the Jacobian
 |      is assumed to be dense.
 |  vectorized : bool, optional
 |      Whether `fun` is implemented in a vectorized fashion. Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number of evaluations of the right-hand side.
 |  njev : int
 |      Number of evaluations of the Jacobian.
 |  nlu : int
 |      Number of LU decompositions.
 |  
 |  References
 |  ----------
 |  .. [1] G. D. Byrne, A. C. Hindmarsh, ""A Polyalgorithm for the Numerical
 |         Solution of Ordinary Differential Equations"", ACM Transactions on
 |         Mathematical Software, Vol. 1, No. 1, pp. 71-96, March 1975.
 |  .. [2] L. F. Shampine, M. W. Reichelt, ""THE MATLAB ODE SUITE"", SIAM J. SCI.
 |         COMPUTE., Vol. 18, No. 1, pp. 1-22, January 1997.
 |  .. [3] E. Hairer, G. Wanner, ""Solving Ordinary Differential Equations I:
 |         Nonstiff Problems"", Sec. III.2.
 |  .. [4] A. Curtis, M. J. D. Powell, and J. Reid, ""On the estimation of
 |         sparse Jacobian matrices"", Journal of the Institute of Mathematics
 |         and its Applications, 13, pp. 117-120, 1974.
 |  
 |  Method resolution order:
 |      BDF
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, jac=None, jac_sparsity=None, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('self', 'fun', 't0', 'y0', 't_bound', 'max_step', 'rtol', 'atol', 'jac', 'jac_sparsity', 'vectorized')","(nan, nan, nan, nan, nan, inf, 0.001, 1e-06, None, None, False)","(nan, nan, nan, nan, nan, 'float', 'float', 'float', 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, jac=None, jac_sparsity=None, vectorized=False, **extraneous)',)"
scipy,1.1.0,scipy.integrate._ivp.DenseOutput,integrate._ivp,DenseOutput,"Python Library Documentation: class DenseOutput in module scipy.integrate._ivp.base

class DenseOutput(builtins.object)
 |  Base class for local interpolant over step made by an ODE solver.
 |  
 |  It interpolates between `t_min` and `t_max` (see Attributes below).
 |  Evaluation outside this interval is not forbidden, but the accuracy is not
 |  guaranteed.
 |  
 |  Attributes
 |  ----------
 |  t_min, t_max : float
 |      Time range of the interpolation.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, t)
 |      Evaluate the interpolant.
 |      
 |      Parameters
 |      ----------
 |      t : float or array_like with shape (n_points,)
 |          Points to evaluate the solution at.
 |      
 |      Returns
 |      -------
 |      y : ndarray, shape (n,) or (n, n_points)
 |          Computed values. Shape depends on whether `t` was a scalar or a
 |          1-d array.
 |  
 |  __init__(self, t_old, t)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, t_old, t)',)",scipy,1.1.0,scipy.integrate._ivp.DenseOutput,integrate._ivp,DenseOutput,"Python Library Documentation: class DenseOutput in module scipy.integrate._ivp.base

class DenseOutput(builtins.object)
 |  Base class for local interpolant over step made by an ODE solver.
 |  
 |  It interpolates between `t_min` and `t_max` (see Attributes below).
 |  Evaluation outside this interval is not forbidden, but the accuracy is not
 |  guaranteed.
 |  
 |  Attributes
 |  ----------
 |  t_min, t_max : float
 |      Time range of the interpolation.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, t)
 |      Evaluate the interpolant.
 |      
 |      Parameters
 |      ----------
 |      t : float or array_like with shape (n_points,)
 |          Points to evaluate the solution at.
 |      
 |      Returns
 |      -------
 |      y : ndarray, shape (n,) or (n, n_points)
 |          Computed values. Shape depends on whether `t` was a scalar or a
 |          1-d array.
 |  
 |  __init__(self, t_old, t)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 't_old', 't')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(self, t_old, t)',)"
scipy,1.1.0,scipy.integrate._ivp.LSODA,integrate._ivp,LSODA,"Python Library Documentation: class LSODA in module scipy.integrate._ivp.lsoda

class LSODA(scipy.integrate._ivp.base.OdeSolver)
 |  Adams/BDF method with automatic stiffness detection and switching.
 |  
 |  This is a wrapper to the Fortran solver from ODEPACK [1]_. It switches
 |  automatically between the nonstiff Adams method and the stiff BDF method.
 |  The method was originally detailed in [2]_.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar, and there are two options for the ndarray ``y``:
 |      It can either have shape (n,); then ``fun`` must return array_like with
 |      shape (n,). Alternatively it can have shape (n, k); then ``fun``
 |      must return an array_like with shape (n, k), i.e. each column
 |      corresponds to a single column in ``y``. The choice between the two
 |      options is determined by `vectorized` argument (see below). The
 |      vectorized implementation allows a faster approximation of the Jacobian
 |      by finite differences (required for this solver).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time - the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  first_step : float or None, optional
 |      Initial step size. Default is ``None`` which means that the algorithm
 |      should choose.
 |  min_step : float, optional
 |      Minimum allowed step size. Default is 0.0, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  max_step : float, optional
 |      Maximum allowed step size. Default is np.inf, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  rtol, atol : float and array_like, optional
 |      Relative and absolute tolerances. The solver keeps the local error
 |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
 |      relative accuracy (number of correct digits). But if a component of `y`
 |      is approximately below `atol`, the error only needs to fall within
 |      the same `atol` threshold, and the number of correct digits is not
 |      guaranteed. If components of y have different scales, it might be
 |      beneficial to set different `atol` values for different components by
 |      passing array_like with shape (n,) for `atol`. Default values are
 |      1e-3 for `rtol` and 1e-6 for `atol`.
 |  jac : None or callable, optional
 |      Jacobian matrix of the right-hand side of the system with respect to
 |      ``y``. The Jacobian matrix has shape (n, n) and its element (i, j) is
 |      equal to ``d f_i / d y_j``. The function will be called as
 |      ``jac(t, y)``. If None (default), the Jacobian will be
 |      approximated by finite differences. It is generally recommended to
 |      provide the Jacobian rather than relying on a finite-difference
 |      approximation.
 |  lband, uband : int or None
 |      Parameters defining the bandwidth of the Jacobian,
 |      i.e., ``jac[i, j] != 0 only for i - lband <= j <= i + uband``. Setting
 |      these requires your jac routine to return the Jacobian in the packed format:
 |      the returned array must have ``n`` columns and ``uband + lband + 1``
 |      rows in which Jacobian diagonals are written. Specifically
 |      ``jac_packed[uband + i - j , j] = jac[i, j]``. The same format is used
 |      in `scipy.linalg.solve_banded` (check for an illustration).
 |      These parameters can be also used with ``jac=None`` to reduce the
 |      number of Jacobian elements estimated by finite differences.
 |  vectorized : bool, optional
 |      Whether `fun` is implemented in a vectorized fashion. A vectorized
 |      implementation offers no advantages for this solver. Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  nfev : int
 |      Number of evaluations of the right-hand side.
 |  njev : int
 |      Number of evaluations of the Jacobian.
 |  
 |  References
 |  ----------
 |  .. [1] A. C. Hindmarsh, ""ODEPACK, A Systematized Collection of ODE
 |         Solvers,"" IMACS Transactions on Scientific Computation, Vol 1.,
 |         pp. 55-64, 1983.
 |  .. [2] L. Petzold, ""Automatic selection of methods for solving stiff and
 |         nonstiff systems of ordinary differential equations"", SIAM Journal
 |         on Scientific and Statistical Computing, Vol. 4, No. 1, pp. 136-148,
 |         1983.
 |  
 |  Method resolution order:
 |      LSODA
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, first_step=None, min_step=0.0, max_step=inf, rtol=0.001, atol=1e-06, jac=None, lband=None, uband=None, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('(self, fun, t0, y0, t_bound, first_step=None, min_step=0.0, max_step=inf, rtol=0.001, atol=1e-06, jac=None, lband=None, uband=None, vectorized=False, **extraneous)',)",scipy,1.1.0,scipy.integrate._ivp.LSODA,integrate._ivp,LSODA,"Python Library Documentation: class LSODA in module scipy.integrate._ivp.lsoda

class LSODA(scipy.integrate._ivp.base.OdeSolver)
 |  Adams/BDF method with automatic stiffness detection and switching.
 |  
 |  This is a wrapper to the Fortran solver from ODEPACK [1]_. It switches
 |  automatically between the nonstiff Adams method and the stiff BDF method.
 |  The method was originally detailed in [2]_.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar, and there are two options for the ndarray ``y``:
 |      It can either have shape (n,); then ``fun`` must return array_like with
 |      shape (n,). Alternatively it can have shape (n, k); then ``fun``
 |      must return an array_like with shape (n, k), i.e. each column
 |      corresponds to a single column in ``y``. The choice between the two
 |      options is determined by `vectorized` argument (see below). The
 |      vectorized implementation allows a faster approximation of the Jacobian
 |      by finite differences (required for this solver).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time - the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  first_step : float or None, optional
 |      Initial step size. Default is ``None`` which means that the algorithm
 |      should choose.
 |  min_step : float, optional
 |      Minimum allowed step size. Default is 0.0, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  max_step : float, optional
 |      Maximum allowed step size. Default is np.inf, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  rtol, atol : float and array_like, optional
 |      Relative and absolute tolerances. The solver keeps the local error
 |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
 |      relative accuracy (number of correct digits). But if a component of `y`
 |      is approximately below `atol`, the error only needs to fall within
 |      the same `atol` threshold, and the number of correct digits is not
 |      guaranteed. If components of y have different scales, it might be
 |      beneficial to set different `atol` values for different components by
 |      passing array_like with shape (n,) for `atol`. Default values are
 |      1e-3 for `rtol` and 1e-6 for `atol`.
 |  jac : None or callable, optional
 |      Jacobian matrix of the right-hand side of the system with respect to
 |      ``y``. The Jacobian matrix has shape (n, n) and its element (i, j) is
 |      equal to ``d f_i / d y_j``. The function will be called as
 |      ``jac(t, y)``. If None (default), the Jacobian will be
 |      approximated by finite differences. It is generally recommended to
 |      provide the Jacobian rather than relying on a finite-difference
 |      approximation.
 |  lband, uband : int or None
 |      Parameters defining the bandwidth of the Jacobian,
 |      i.e., ``jac[i, j] != 0 only for i - lband <= j <= i + uband``. Setting
 |      these requires your jac routine to return the Jacobian in the packed format:
 |      the returned array must have ``n`` columns and ``uband + lband + 1``
 |      rows in which Jacobian diagonals are written. Specifically
 |      ``jac_packed[uband + i - j , j] = jac[i, j]``. The same format is used
 |      in `scipy.linalg.solve_banded` (check for an illustration).
 |      These parameters can be also used with ``jac=None`` to reduce the
 |      number of Jacobian elements estimated by finite differences.
 |  vectorized : bool, optional
 |      Whether `fun` is implemented in a vectorized fashion. A vectorized
 |      implementation offers no advantages for this solver. Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  nfev : int
 |      Number of evaluations of the right-hand side.
 |  njev : int
 |      Number of evaluations of the Jacobian.
 |  
 |  References
 |  ----------
 |  .. [1] A. C. Hindmarsh, ""ODEPACK, A Systematized Collection of ODE
 |         Solvers,"" IMACS Transactions on Scientific Computation, Vol 1.,
 |         pp. 55-64, 1983.
 |  .. [2] L. Petzold, ""Automatic selection of methods for solving stiff and
 |         nonstiff systems of ordinary differential equations"", SIAM Journal
 |         on Scientific and Statistical Computing, Vol. 4, No. 1, pp. 136-148,
 |         1983.
 |  
 |  Method resolution order:
 |      LSODA
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, first_step=None, min_step=0.0, max_step=inf, rtol=0.001, atol=1e-06, jac=None, lband=None, uband=None, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('self', 'fun', 't0', 'y0', 't_bound', 'first_step', 'min_step', 'max_step', 'rtol', 'atol', 'jac', 'lband', 'uband', 'vectorized')","(nan, nan, nan, nan, nan, None, 0.0, inf, 0.001, 1e-06, None, None, None, False)","(nan, nan, nan, nan, nan, 'NoneType', 'float', 'float', 'float', 'float', 'NoneType', 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, fun, t0, y0, t_bound, first_step=None, min_step=0.0, max_step=inf, rtol=0.001, atol=1e-06, jac=None, lband=None, uband=None, vectorized=False, **extraneous)',)"
scipy,1.1.0,scipy.integrate._ivp.OdeSolution,integrate._ivp,OdeSolution,"Python Library Documentation: class OdeSolution in module scipy.integrate._ivp.common

class OdeSolution(builtins.object)
 |  Continuous ODE solution.
 |  
 |  It is organized as a collection of `DenseOutput` objects which represent
 |  local interpolants. It provides an algorithm to select a right interpolant
 |  for each given point.
 |  
 |  The interpolants cover the range between `t_min` and `t_max` (see
 |  Attributes below). Evaluation outside this interval is not forbidden, but
 |  the accuracy is not guaranteed.
 |  
 |  When evaluating at a breakpoint (one of the values in `ts`) a segment with
 |  the lower index is selected.
 |  
 |  Parameters
 |  ----------
 |  ts : array_like, shape (n_segments + 1,)
 |      Time instants between which local interpolants are defined. Must
 |      be strictly increasing or decreasing (zero segment with two points is
 |      also allowed).
 |  interpolants : list of DenseOutput with n_segments elements
 |      Local interpolants. An i-th interpolant is assumed to be defined
 |      between ``ts[i]`` and ``ts[i + 1]``.
 |  
 |  Attributes
 |  ----------
 |  t_min, t_max : float
 |      Time range of the interpolation.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, t)
 |      Evaluate the solution.
 |      
 |      Parameters
 |      ----------
 |      t : float or array_like with shape (n_points,)
 |          Points to evaluate at.
 |      
 |      Returns
 |      -------
 |      y : ndarray, shape (n_states,) or (n_states, n_points)
 |          Computed values. Shape depends on whether `t` is a scalar or a
 |          1-d array.
 |  
 |  __init__(self, ts, interpolants)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, ts, interpolants)',)",scipy,1.1.0,scipy.integrate._ivp.OdeSolution,integrate._ivp,OdeSolution,"Python Library Documentation: class OdeSolution in module scipy.integrate._ivp.common

class OdeSolution(builtins.object)
 |  Continuous ODE solution.
 |  
 |  It is organized as a collection of `DenseOutput` objects which represent
 |  local interpolants. It provides an algorithm to select a right interpolant
 |  for each given point.
 |  
 |  The interpolants cover the range between `t_min` and `t_max` (see
 |  Attributes below). Evaluation outside this interval is not forbidden, but
 |  the accuracy is not guaranteed.
 |  
 |  When evaluating at a breakpoint (one of the values in `ts`) a segment with
 |  the lower index is selected.
 |  
 |  Parameters
 |  ----------
 |  ts : array_like, shape (n_segments + 1,)
 |      Time instants between which local interpolants are defined. Must
 |      be strictly increasing or decreasing (zero segment with two points is
 |      also allowed).
 |  interpolants : list of DenseOutput with n_segments elements
 |      Local interpolants. An i-th interpolant is assumed to be defined
 |      between ``ts[i]`` and ``ts[i + 1]``.
 |  
 |  Attributes
 |  ----------
 |  t_min, t_max : float
 |      Time range of the interpolation.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, t)
 |      Evaluate the solution.
 |      
 |      Parameters
 |      ----------
 |      t : float or array_like with shape (n_points,)
 |          Points to evaluate at.
 |      
 |      Returns
 |      -------
 |      y : ndarray, shape (n_states,) or (n_states, n_points)
 |          Computed values. Shape depends on whether `t` is a scalar or a
 |          1-d array.
 |  
 |  __init__(self, ts, interpolants)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'ts', 'interpolants')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(self, ts, interpolants)',)"
scipy,1.1.0,scipy.integrate._ivp.OdeSolver,integrate._ivp,OdeSolver,"Python Library Documentation: class OdeSolver in module scipy.integrate._ivp.base

class OdeSolver(builtins.object)
 |  Base class for ODE solvers.
 |  
 |  In order to implement a new solver you need to follow the guidelines:
 |  
 |      1. A constructor must accept parameters presented in the base class
 |         (listed below) along with any other parameters specific to a solver.
 |      2. A constructor must accept arbitrary extraneous arguments
 |         ``**extraneous``, but warn that these arguments are irrelevant
 |         using `common.warn_extraneous` function. Do not pass these
 |         arguments to the base class.
 |      3. A solver must implement a private method `_step_impl(self)` which
 |         propagates a solver one step further. It must return tuple
 |         ``(success, message)``, where ``success`` is a boolean indicating
 |         whether a step was successful, and ``message`` is a string
 |         containing description of a failure if a step failed or None
 |         otherwise.
 |      4. A solver must implement a private method `_dense_output_impl(self)`
 |         which returns a `DenseOutput` object covering the last successful
 |         step.
 |      5. A solver must have attributes listed below in Attributes section.
 |         Note that `t_old` and `step_size` are updated automatically.
 |      6. Use `fun(self, t, y)` method for the system rhs evaluation, this
 |         way the number of function evaluations (`nfev`) will be tracked
 |         automatically.
 |      7. For convenience a base class provides `fun_single(self, t, y)` and
 |         `fun_vectorized(self, t, y)` for evaluating the rhs in
 |         non-vectorized and vectorized fashions respectively (regardless of
 |         how `fun` from the constructor is implemented). These calls don't
 |         increment `nfev`.
 |      8. If a solver uses a Jacobian matrix and LU decompositions, it should
 |         track the number of Jacobian evaluations (`njev`) and the number of
 |         LU decompositions (`nlu`).
 |      9. By convention the function evaluations used to compute a finite
 |         difference approximation of the Jacobian should not be counted in
 |         `nfev`, thus use `fun_single(self, t, y)` or
 |         `fun_vectorized(self, t, y)` when computing a finite difference
 |         approximation of the Jacobian.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar and there are two options for ndarray ``y``.
 |      It can either have shape (n,), then ``fun`` must return array_like with
 |      shape (n,). Or alternatively it can have shape (n, n_points), then
 |      ``fun`` must return array_like with shape (n, n_points) (each column
 |      corresponds to a single column in ``y``). The choice between the two
 |      options is determined by `vectorized` argument (see below).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time --- the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  vectorized : bool
 |      Whether `fun` is implemented in a vectorized fashion.
 |  support_complex : bool, optional
 |      Whether integration in a complex domain should be supported.
 |      Generally determined by a derived solver class capabilities.
 |      Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number of the system's rhs evaluations.
 |  njev : int
 |      Number of the Jacobian evaluations.
 |  nlu : int
 |      Number of LU decompositions.
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, vectorized, support_complex=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('(self, fun, t0, y0, t_bound, vectorized, support_complex=False)',)",scipy,1.1.0,scipy.integrate._ivp.OdeSolver,integrate._ivp,OdeSolver,"Python Library Documentation: class OdeSolver in module scipy.integrate._ivp.base

class OdeSolver(builtins.object)
 |  Base class for ODE solvers.
 |  
 |  In order to implement a new solver you need to follow the guidelines:
 |  
 |      1. A constructor must accept parameters presented in the base class
 |         (listed below) along with any other parameters specific to a solver.
 |      2. A constructor must accept arbitrary extraneous arguments
 |         ``**extraneous``, but warn that these arguments are irrelevant
 |         using `common.warn_extraneous` function. Do not pass these
 |         arguments to the base class.
 |      3. A solver must implement a private method `_step_impl(self)` which
 |         propagates a solver one step further. It must return tuple
 |         ``(success, message)``, where ``success`` is a boolean indicating
 |         whether a step was successful, and ``message`` is a string
 |         containing description of a failure if a step failed or None
 |         otherwise.
 |      4. A solver must implement a private method `_dense_output_impl(self)`
 |         which returns a `DenseOutput` object covering the last successful
 |         step.
 |      5. A solver must have attributes listed below in Attributes section.
 |         Note that `t_old` and `step_size` are updated automatically.
 |      6. Use `fun(self, t, y)` method for the system rhs evaluation, this
 |         way the number of function evaluations (`nfev`) will be tracked
 |         automatically.
 |      7. For convenience a base class provides `fun_single(self, t, y)` and
 |         `fun_vectorized(self, t, y)` for evaluating the rhs in
 |         non-vectorized and vectorized fashions respectively (regardless of
 |         how `fun` from the constructor is implemented). These calls don't
 |         increment `nfev`.
 |      8. If a solver uses a Jacobian matrix and LU decompositions, it should
 |         track the number of Jacobian evaluations (`njev`) and the number of
 |         LU decompositions (`nlu`).
 |      9. By convention the function evaluations used to compute a finite
 |         difference approximation of the Jacobian should not be counted in
 |         `nfev`, thus use `fun_single(self, t, y)` or
 |         `fun_vectorized(self, t, y)` when computing a finite difference
 |         approximation of the Jacobian.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar and there are two options for ndarray ``y``.
 |      It can either have shape (n,), then ``fun`` must return array_like with
 |      shape (n,). Or alternatively it can have shape (n, n_points), then
 |      ``fun`` must return array_like with shape (n, n_points) (each column
 |      corresponds to a single column in ``y``). The choice between the two
 |      options is determined by `vectorized` argument (see below).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time --- the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  vectorized : bool
 |      Whether `fun` is implemented in a vectorized fashion.
 |  support_complex : bool, optional
 |      Whether integration in a complex domain should be supported.
 |      Generally determined by a derived solver class capabilities.
 |      Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number of the system's rhs evaluations.
 |  njev : int
 |      Number of the Jacobian evaluations.
 |  nlu : int
 |      Number of LU decompositions.
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, vectorized, support_complex=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('self', 'fun', 't0', 'y0', 't_bound', 'vectorized', 'support_complex')","(nan, nan, nan, nan, nan, nan, False)","(nan, nan, nan, nan, nan, nan, 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, fun, t0, y0, t_bound, vectorized, support_complex=False)',)"
scipy,1.1.0,scipy.integrate._ivp.RK23,integrate._ivp,RK23,"Python Library Documentation: class RK23 in module scipy.integrate._ivp.rk

class RK23(RungeKutta)
 |  Explicit Runge-Kutta method of order 3(2).
 |  
 |  This uses the Bogacki-Shampine pair of formulas [1]_. The error is controlled
 |  assuming accuracy of the second-order method, but steps are taken using the
 |  third-order accurate formula (local extrapolation is done). A cubic Hermite
 |  polynomial is used for the dense output.
 |  
 |  Can be applied in the complex domain.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar and there are two options for ndarray ``y``.
 |      It can either have shape (n,), then ``fun`` must return array_like with
 |      shape (n,). Or alternatively it can have shape (n, k), then ``fun``
 |      must return array_like with shape (n, k), i.e. each column
 |      corresponds to a single column in ``y``. The choice between the two
 |      options is determined by `vectorized` argument (see below).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time - the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  max_step : float, optional
 |      Maximum allowed step size. Default is np.inf, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  rtol, atol : float and array_like, optional
 |      Relative and absolute tolerances. The solver keeps the local error
 |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
 |      relative accuracy (number of correct digits). But if a component of `y`
 |      is approximately below `atol`, the error only needs to fall within
 |      the same `atol` threshold, and the number of correct digits is not
 |      guaranteed. If components of y have different scales, it might be
 |      beneficial to set different `atol` values for different components by
 |      passing array_like with shape (n,) for `atol`. Default values are
 |      1e-3 for `rtol` and 1e-6 for `atol`.
 |  vectorized : bool, optional
 |      Whether `fun` is implemented in a vectorized fashion. Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number evaluations of the system's right-hand side.
 |  njev : int
 |      Number of evaluations of the Jacobian. Is always 0 for this solver as it does not use the Jacobian.
 |  nlu : int
 |      Number of LU decompositions. Is always 0 for this solver.
 |  
 |  References
 |  ----------
 |  .. [1] P. Bogacki, L.F. Shampine, ""A 3(2) Pair of Runge-Kutta Formulas"",
 |         Appl. Math. Lett. Vol. 2, No. 4. pp. 321-325, 1989.
 |  
 |  Method resolution order:
 |      RK23
 |      RungeKutta
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Data and other attributes defined here:
 |  
 |  A = [array([0.5]), array([0.  , 0.75])]
 |  
 |  B = array([0.22222222, 0.33333333, 0.44444444])
 |  
 |  C = array([0.5 , 0.75])
 |  
 |  E = array([ 0.06944444, -0.08333333, -0.11111111,  0.125     ])
 |  
 |  P = array([[ 1.        , -1.33333333,  0.55555556],
 |  ...
 |         [ 0.   ...
 |  
 |  n_stages = 3
 |  
 |  order = 2
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from RungeKutta:
 |  
 |  __init__(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, vectorized=False, **extraneous)',)",scipy,1.1.0,scipy.integrate._ivp.RK23,integrate._ivp,RK23,"Python Library Documentation: class RK23 in module scipy.integrate._ivp.rk

class RK23(RungeKutta)
 |  Explicit Runge-Kutta method of order 3(2).
 |  
 |  This uses the Bogacki-Shampine pair of formulas [1]_. The error is controlled
 |  assuming accuracy of the second-order method, but steps are taken using the
 |  third-order accurate formula (local extrapolation is done). A cubic Hermite
 |  polynomial is used for the dense output.
 |  
 |  Can be applied in the complex domain.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar and there are two options for ndarray ``y``.
 |      It can either have shape (n,), then ``fun`` must return array_like with
 |      shape (n,). Or alternatively it can have shape (n, k), then ``fun``
 |      must return array_like with shape (n, k), i.e. each column
 |      corresponds to a single column in ``y``. The choice between the two
 |      options is determined by `vectorized` argument (see below).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time - the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  max_step : float, optional
 |      Maximum allowed step size. Default is np.inf, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  rtol, atol : float and array_like, optional
 |      Relative and absolute tolerances. The solver keeps the local error
 |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
 |      relative accuracy (number of correct digits). But if a component of `y`
 |      is approximately below `atol`, the error only needs to fall within
 |      the same `atol` threshold, and the number of correct digits is not
 |      guaranteed. If components of y have different scales, it might be
 |      beneficial to set different `atol` values for different components by
 |      passing array_like with shape (n,) for `atol`. Default values are
 |      1e-3 for `rtol` and 1e-6 for `atol`.
 |  vectorized : bool, optional
 |      Whether `fun` is implemented in a vectorized fashion. Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number evaluations of the system's right-hand side.
 |  njev : int
 |      Number of evaluations of the Jacobian. Is always 0 for this solver as it does not use the Jacobian.
 |  nlu : int
 |      Number of LU decompositions. Is always 0 for this solver.
 |  
 |  References
 |  ----------
 |  .. [1] P. Bogacki, L.F. Shampine, ""A 3(2) Pair of Runge-Kutta Formulas"",
 |         Appl. Math. Lett. Vol. 2, No. 4. pp. 321-325, 1989.
 |  
 |  Method resolution order:
 |      RK23
 |      RungeKutta
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Data and other attributes defined here:
 |  
 |  A = [array([0.5]), array([0.  , 0.75])]
 |  
 |  B = array([0.22222222, 0.33333333, 0.44444444])
 |  
 |  C = array([0.5 , 0.75])
 |  
 |  E = array([ 0.06944444, -0.08333333, -0.11111111,  0.125     ])
 |  
 |  P = array([[ 1.        , -1.33333333,  0.55555556],
 |  ...
 |         [ 0.   ...
 |  
 |  n_stages = 3
 |  
 |  order = 2
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from RungeKutta:
 |  
 |  __init__(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('self', 'fun', 't0', 'y0', 't_bound', 'max_step', 'rtol', 'atol', 'vectorized')","(nan, nan, nan, nan, nan, inf, 0.001, 1e-06, False)","(nan, nan, nan, nan, nan, 'float', 'float', 'float', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, vectorized=False, **extraneous)',)"
scipy,1.1.0,scipy.integrate._ivp.RK45,integrate._ivp,RK45,"Python Library Documentation: class RK45 in module scipy.integrate._ivp.rk

class RK45(RungeKutta)
 |  Explicit Runge-Kutta method of order 5(4).
 |  
 |  This uses the Dormand-Prince pair of formulas [1]_. The error is controlled
 |  assuming accuracy of the fourth-order method accuracy, but steps are taken
 |  using the fifth-order accurate formula (local extrapolation is done).
 |  A quartic interpolation polynomial is used for the dense output [2]_.
 |  
 |  Can be applied in the complex domain.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar, and there are two options for the ndarray ``y``:
 |      It can either have shape (n,); then ``fun`` must return array_like with
 |      shape (n,). Alternatively it can have shape (n, k); then ``fun``
 |      must return an array_like with shape (n, k), i.e. each column
 |      corresponds to a single column in ``y``. The choice between the two
 |      options is determined by `vectorized` argument (see below).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time - the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  max_step : float, optional
 |      Maximum allowed step size. Default is np.inf, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  rtol, atol : float and array_like, optional
 |      Relative and absolute tolerances. The solver keeps the local error
 |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
 |      relative accuracy (number of correct digits). But if a component of `y`
 |      is approximately below `atol`, the error only needs to fall within
 |      the same `atol` threshold, and the number of correct digits is not
 |      guaranteed. If components of y have different scales, it might be
 |      beneficial to set different `atol` values for different components by
 |      passing array_like with shape (n,) for `atol`. Default values are
 |      1e-3 for `rtol` and 1e-6 for `atol`.
 |  vectorized : bool, optional
 |      Whether `fun` is implemented in a vectorized fashion. Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number evaluations of the system's right-hand side.
 |  njev : int
 |      Number of evaluations of the Jacobian. Is always 0 for this solver as it does not use the Jacobian.
 |  nlu : int
 |      Number of LU decompositions. Is always 0 for this solver.
 |  
 |  References
 |  ----------
 |  .. [1] J. R. Dormand, P. J. Prince, ""A family of embedded Runge-Kutta
 |         formulae"", Journal of Computational and Applied Mathematics, Vol. 6,
 |         No. 1, pp. 19-26, 1980.
 |  .. [2] L. W. Shampine, ""Some Practical Runge-Kutta Formulas"", Mathematics
 |         of Computation,, Vol. 46, No. 173, pp. 135-150, 1986.
 |  
 |  Method resolution order:
 |      RK45
 |      RungeKutta
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Data and other attributes defined here:
 |  
 |  A = [array([0.2]), array([0.075, 0.225]), array([ 0.97777778, -3.73333...
 |  
 |  B = array([ 0.09114583,  0.        ,  0.4492363 ,  0.65104167, -0.3223...
 |  
 |  C = array([0.2       , 0.3       , 0.8       , 0.88888889, 1.        ]...
 |  
 |  E = array([-0.00123264,  0.        ,  0.00425277, -0...7,  0.0508638 ,...
 |  
 |  P = array([[ 1.        , -2.85358007,  3.07174346, -...       ,  1.382...
 |  
 |  n_stages = 6
 |  
 |  order = 4
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from RungeKutta:
 |  
 |  __init__(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, vectorized=False, **extraneous)',)",scipy,1.1.0,scipy.integrate._ivp.RK45,integrate._ivp,RK45,"Python Library Documentation: class RK45 in module scipy.integrate._ivp.rk

class RK45(RungeKutta)
 |  Explicit Runge-Kutta method of order 5(4).
 |  
 |  This uses the Dormand-Prince pair of formulas [1]_. The error is controlled
 |  assuming accuracy of the fourth-order method accuracy, but steps are taken
 |  using the fifth-order accurate formula (local extrapolation is done).
 |  A quartic interpolation polynomial is used for the dense output [2]_.
 |  
 |  Can be applied in the complex domain.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar, and there are two options for the ndarray ``y``:
 |      It can either have shape (n,); then ``fun`` must return array_like with
 |      shape (n,). Alternatively it can have shape (n, k); then ``fun``
 |      must return an array_like with shape (n, k), i.e. each column
 |      corresponds to a single column in ``y``. The choice between the two
 |      options is determined by `vectorized` argument (see below).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time - the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  max_step : float, optional
 |      Maximum allowed step size. Default is np.inf, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  rtol, atol : float and array_like, optional
 |      Relative and absolute tolerances. The solver keeps the local error
 |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
 |      relative accuracy (number of correct digits). But if a component of `y`
 |      is approximately below `atol`, the error only needs to fall within
 |      the same `atol` threshold, and the number of correct digits is not
 |      guaranteed. If components of y have different scales, it might be
 |      beneficial to set different `atol` values for different components by
 |      passing array_like with shape (n,) for `atol`. Default values are
 |      1e-3 for `rtol` and 1e-6 for `atol`.
 |  vectorized : bool, optional
 |      Whether `fun` is implemented in a vectorized fashion. Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number evaluations of the system's right-hand side.
 |  njev : int
 |      Number of evaluations of the Jacobian. Is always 0 for this solver as it does not use the Jacobian.
 |  nlu : int
 |      Number of LU decompositions. Is always 0 for this solver.
 |  
 |  References
 |  ----------
 |  .. [1] J. R. Dormand, P. J. Prince, ""A family of embedded Runge-Kutta
 |         formulae"", Journal of Computational and Applied Mathematics, Vol. 6,
 |         No. 1, pp. 19-26, 1980.
 |  .. [2] L. W. Shampine, ""Some Practical Runge-Kutta Formulas"", Mathematics
 |         of Computation,, Vol. 46, No. 173, pp. 135-150, 1986.
 |  
 |  Method resolution order:
 |      RK45
 |      RungeKutta
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Data and other attributes defined here:
 |  
 |  A = [array([0.2]), array([0.075, 0.225]), array([ 0.97777778, -3.73333...
 |  
 |  B = array([ 0.09114583,  0.        ,  0.4492363 ,  0.65104167, -0.3223...
 |  
 |  C = array([0.2       , 0.3       , 0.8       , 0.88888889, 1.        ]...
 |  
 |  E = array([-0.00123264,  0.        ,  0.00425277, -0...7,  0.0508638 ,...
 |  
 |  P = array([[ 1.        , -2.85358007,  3.07174346, -...       ,  1.382...
 |  
 |  n_stages = 6
 |  
 |  order = 4
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from RungeKutta:
 |  
 |  __init__(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('self', 'fun', 't0', 'y0', 't_bound', 'max_step', 'rtol', 'atol', 'vectorized')","(nan, nan, nan, nan, nan, inf, 0.001, 1e-06, False)","(nan, nan, nan, nan, nan, 'float', 'float', 'float', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, vectorized=False, **extraneous)',)"
scipy,1.1.0,scipy.integrate._ivp.Radau,integrate._ivp,Radau,"Python Library Documentation: class Radau in module scipy.integrate._ivp.radau

class Radau(scipy.integrate._ivp.base.OdeSolver)
 |  Implicit Runge-Kutta method of Radau IIA family of order 5.
 |  
 |  The implementation follows [1]_. The error is controlled with a
 |  third-order accurate embedded formula. A cubic polynomial which satisfies
 |  the collocation conditions is used for the dense output.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar, and there are two options for the ndarray ``y``:
 |      It can either have shape (n,); then ``fun`` must return array_like with
 |      shape (n,). Alternatively it can have shape (n, k); then ``fun``
 |      must return an array_like with shape (n, k), i.e. each column
 |      corresponds to a single column in ``y``. The choice between the two
 |      options is determined by `vectorized` argument (see below). The
 |      vectorized implementation allows a faster approximation of the Jacobian
 |      by finite differences (required for this solver).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time - the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  max_step : float, optional
 |      Maximum allowed step size. Default is np.inf, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  rtol, atol : float and array_like, optional
 |      Relative and absolute tolerances. The solver keeps the local error
 |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
 |      relative accuracy (number of correct digits). But if a component of `y`
 |      is approximately below `atol`, the error only needs to fall within
 |      the same `atol` threshold, and the number of correct digits is not
 |      guaranteed. If components of y have different scales, it might be
 |      beneficial to set different `atol` values for different components by
 |      passing array_like with shape (n,) for `atol`. Default values are
 |      1e-3 for `rtol` and 1e-6 for `atol`.
 |  jac : {None, array_like, sparse_matrix, callable}, optional
 |      Jacobian matrix of the right-hand side of the system with respect to
 |      y, required by this method. The Jacobian matrix has shape (n, n) and
 |      its element (i, j) is equal to ``d f_i / d y_j``.
 |      There are three ways to define the Jacobian:
 |  
 |          * If array_like or sparse_matrix, the Jacobian is assumed to
 |            be constant.
 |          * If callable, the Jacobian is assumed to depend on both
 |            t and y; it will be called as ``jac(t, y)`` as necessary.
 |            For the 'Radau' and 'BDF' methods, the return value might be a
 |            sparse matrix.
 |          * If None (default), the Jacobian will be approximated by
 |            finite differences.
 |  
 |      It is generally recommended to provide the Jacobian rather than
 |      relying on a finite-difference approximation.
 |  jac_sparsity : {None, array_like, sparse matrix}, optional
 |      Defines a sparsity structure of the Jacobian matrix for a
 |      finite-difference approximation. Its shape must be (n, n). This argument
 |      is ignored if `jac` is not `None`. If the Jacobian has only few non-zero
 |      elements in *each* row, providing the sparsity structure will greatly
 |      speed up the computations [2]_. A zero entry means that a corresponding
 |      element in the Jacobian is always zero. If None (default), the Jacobian
 |      is assumed to be dense.
 |  vectorized : bool, optional
 |      Whether `fun` is implemented in a vectorized fashion. Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number of evaluations of the right-hand side.
 |  njev : int
 |      Number of evaluations of the Jacobian.
 |  nlu : int
 |      Number of LU decompositions.
 |  
 |  References
 |  ----------
 |  .. [1] E. Hairer, G. Wanner, ""Solving Ordinary Differential Equations II:
 |         Stiff and Differential-Algebraic Problems"", Sec. IV.8.
 |  .. [2] A. Curtis, M. J. D. Powell, and J. Reid, ""On the estimation of
 |         sparse Jacobian matrices"", Journal of the Institute of Mathematics
 |         and its Applications, 13, pp. 117-120, 1974.
 |  
 |  Method resolution order:
 |      Radau
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, jac=None, jac_sparsity=None, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, jac=None, jac_sparsity=None, vectorized=False, **extraneous)',)",scipy,1.1.0,scipy.integrate._ivp.Radau,integrate._ivp,Radau,"Python Library Documentation: class Radau in module scipy.integrate._ivp.radau

class Radau(scipy.integrate._ivp.base.OdeSolver)
 |  Implicit Runge-Kutta method of Radau IIA family of order 5.
 |  
 |  The implementation follows [1]_. The error is controlled with a
 |  third-order accurate embedded formula. A cubic polynomial which satisfies
 |  the collocation conditions is used for the dense output.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar, and there are two options for the ndarray ``y``:
 |      It can either have shape (n,); then ``fun`` must return array_like with
 |      shape (n,). Alternatively it can have shape (n, k); then ``fun``
 |      must return an array_like with shape (n, k), i.e. each column
 |      corresponds to a single column in ``y``. The choice between the two
 |      options is determined by `vectorized` argument (see below). The
 |      vectorized implementation allows a faster approximation of the Jacobian
 |      by finite differences (required for this solver).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time - the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  max_step : float, optional
 |      Maximum allowed step size. Default is np.inf, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  rtol, atol : float and array_like, optional
 |      Relative and absolute tolerances. The solver keeps the local error
 |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
 |      relative accuracy (number of correct digits). But if a component of `y`
 |      is approximately below `atol`, the error only needs to fall within
 |      the same `atol` threshold, and the number of correct digits is not
 |      guaranteed. If components of y have different scales, it might be
 |      beneficial to set different `atol` values for different components by
 |      passing array_like with shape (n,) for `atol`. Default values are
 |      1e-3 for `rtol` and 1e-6 for `atol`.
 |  jac : {None, array_like, sparse_matrix, callable}, optional
 |      Jacobian matrix of the right-hand side of the system with respect to
 |      y, required by this method. The Jacobian matrix has shape (n, n) and
 |      its element (i, j) is equal to ``d f_i / d y_j``.
 |      There are three ways to define the Jacobian:
 |  
 |          * If array_like or sparse_matrix, the Jacobian is assumed to
 |            be constant.
 |          * If callable, the Jacobian is assumed to depend on both
 |            t and y; it will be called as ``jac(t, y)`` as necessary.
 |            For the 'Radau' and 'BDF' methods, the return value might be a
 |            sparse matrix.
 |          * If None (default), the Jacobian will be approximated by
 |            finite differences.
 |  
 |      It is generally recommended to provide the Jacobian rather than
 |      relying on a finite-difference approximation.
 |  jac_sparsity : {None, array_like, sparse matrix}, optional
 |      Defines a sparsity structure of the Jacobian matrix for a
 |      finite-difference approximation. Its shape must be (n, n). This argument
 |      is ignored if `jac` is not `None`. If the Jacobian has only few non-zero
 |      elements in *each* row, providing the sparsity structure will greatly
 |      speed up the computations [2]_. A zero entry means that a corresponding
 |      element in the Jacobian is always zero. If None (default), the Jacobian
 |      is assumed to be dense.
 |  vectorized : bool, optional
 |      Whether `fun` is implemented in a vectorized fashion. Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number of evaluations of the right-hand side.
 |  njev : int
 |      Number of evaluations of the Jacobian.
 |  nlu : int
 |      Number of LU decompositions.
 |  
 |  References
 |  ----------
 |  .. [1] E. Hairer, G. Wanner, ""Solving Ordinary Differential Equations II:
 |         Stiff and Differential-Algebraic Problems"", Sec. IV.8.
 |  .. [2] A. Curtis, M. J. D. Powell, and J. Reid, ""On the estimation of
 |         sparse Jacobian matrices"", Journal of the Institute of Mathematics
 |         and its Applications, 13, pp. 117-120, 1974.
 |  
 |  Method resolution order:
 |      Radau
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, jac=None, jac_sparsity=None, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('self', 'fun', 't0', 'y0', 't_bound', 'max_step', 'rtol', 'atol', 'jac', 'jac_sparsity', 'vectorized')","(nan, nan, nan, nan, nan, inf, 0.001, 1e-06, None, None, False)","(nan, nan, nan, nan, nan, 'float', 'float', 'float', 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, jac=None, jac_sparsity=None, vectorized=False, **extraneous)',)"
scipy,1.1.0,scipy.integrate._ivp.base.ConstantDenseOutput,integrate._ivp.base,ConstantDenseOutput,"Python Library Documentation: class ConstantDenseOutput in module scipy.integrate._ivp.base

class ConstantDenseOutput(DenseOutput)
 |  Constant value interpolator.
 |  
 |  This class used for degenerate integration cases: equal integration limits
 |  or a system with 0 equations.
 |  
 |  Method resolution order:
 |      ConstantDenseOutput
 |      DenseOutput
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, t_old, t, value)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from DenseOutput:
 |  
 |  __call__(self, t)
 |      Evaluate the interpolant.
 |      
 |      Parameters
 |      ----------
 |      t : float or array_like with shape (n_points,)
 |          Points to evaluate the solution at.
 |      
 |      Returns
 |      -------
 |      y : ndarray, shape (n,) or (n, n_points)
 |          Computed values. Shape depends on whether `t` was a scalar or a
 |          1-d array.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from DenseOutput:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, t_old, t, value)',)",scipy,1.1.0,scipy.integrate._ivp.base.ConstantDenseOutput,integrate._ivp.base,ConstantDenseOutput,"Python Library Documentation: class ConstantDenseOutput in module scipy.integrate._ivp.base

class ConstantDenseOutput(DenseOutput)
 |  Constant value interpolator.
 |  
 |  This class used for degenerate integration cases: equal integration limits
 |  or a system with 0 equations.
 |  
 |  Method resolution order:
 |      ConstantDenseOutput
 |      DenseOutput
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, t_old, t, value)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from DenseOutput:
 |  
 |  __call__(self, t)
 |      Evaluate the interpolant.
 |      
 |      Parameters
 |      ----------
 |      t : float or array_like with shape (n_points,)
 |          Points to evaluate the solution at.
 |      
 |      Returns
 |      -------
 |      y : ndarray, shape (n,) or (n, n_points)
 |          Computed values. Shape depends on whether `t` was a scalar or a
 |          1-d array.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from DenseOutput:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 't_old', 't', 'value')","(nan, nan, nan, nan)","(nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, t_old, t, value)',)"
scipy,1.1.0,scipy.integrate._ivp.base.DenseOutput,integrate._ivp.base,DenseOutput,"Python Library Documentation: class DenseOutput in module scipy.integrate._ivp.base

class DenseOutput(builtins.object)
 |  Base class for local interpolant over step made by an ODE solver.
 |  
 |  It interpolates between `t_min` and `t_max` (see Attributes below).
 |  Evaluation outside this interval is not forbidden, but the accuracy is not
 |  guaranteed.
 |  
 |  Attributes
 |  ----------
 |  t_min, t_max : float
 |      Time range of the interpolation.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, t)
 |      Evaluate the interpolant.
 |      
 |      Parameters
 |      ----------
 |      t : float or array_like with shape (n_points,)
 |          Points to evaluate the solution at.
 |      
 |      Returns
 |      -------
 |      y : ndarray, shape (n,) or (n, n_points)
 |          Computed values. Shape depends on whether `t` was a scalar or a
 |          1-d array.
 |  
 |  __init__(self, t_old, t)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, t_old, t)',)",scipy,1.1.0,scipy.integrate._ivp.base.DenseOutput,integrate._ivp.base,DenseOutput,"Python Library Documentation: class DenseOutput in module scipy.integrate._ivp.base

class DenseOutput(builtins.object)
 |  Base class for local interpolant over step made by an ODE solver.
 |  
 |  It interpolates between `t_min` and `t_max` (see Attributes below).
 |  Evaluation outside this interval is not forbidden, but the accuracy is not
 |  guaranteed.
 |  
 |  Attributes
 |  ----------
 |  t_min, t_max : float
 |      Time range of the interpolation.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, t)
 |      Evaluate the interpolant.
 |      
 |      Parameters
 |      ----------
 |      t : float or array_like with shape (n_points,)
 |          Points to evaluate the solution at.
 |      
 |      Returns
 |      -------
 |      y : ndarray, shape (n,) or (n, n_points)
 |          Computed values. Shape depends on whether `t` was a scalar or a
 |          1-d array.
 |  
 |  __init__(self, t_old, t)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 't_old', 't')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(self, t_old, t)',)"
scipy,1.1.0,scipy.integrate._ivp.base.OdeSolver,integrate._ivp.base,OdeSolver,"Python Library Documentation: class OdeSolver in module scipy.integrate._ivp.base

class OdeSolver(builtins.object)
 |  Base class for ODE solvers.
 |  
 |  In order to implement a new solver you need to follow the guidelines:
 |  
 |      1. A constructor must accept parameters presented in the base class
 |         (listed below) along with any other parameters specific to a solver.
 |      2. A constructor must accept arbitrary extraneous arguments
 |         ``**extraneous``, but warn that these arguments are irrelevant
 |         using `common.warn_extraneous` function. Do not pass these
 |         arguments to the base class.
 |      3. A solver must implement a private method `_step_impl(self)` which
 |         propagates a solver one step further. It must return tuple
 |         ``(success, message)``, where ``success`` is a boolean indicating
 |         whether a step was successful, and ``message`` is a string
 |         containing description of a failure if a step failed or None
 |         otherwise.
 |      4. A solver must implement a private method `_dense_output_impl(self)`
 |         which returns a `DenseOutput` object covering the last successful
 |         step.
 |      5. A solver must have attributes listed below in Attributes section.
 |         Note that `t_old` and `step_size` are updated automatically.
 |      6. Use `fun(self, t, y)` method for the system rhs evaluation, this
 |         way the number of function evaluations (`nfev`) will be tracked
 |         automatically.
 |      7. For convenience a base class provides `fun_single(self, t, y)` and
 |         `fun_vectorized(self, t, y)` for evaluating the rhs in
 |         non-vectorized and vectorized fashions respectively (regardless of
 |         how `fun` from the constructor is implemented). These calls don't
 |         increment `nfev`.
 |      8. If a solver uses a Jacobian matrix and LU decompositions, it should
 |         track the number of Jacobian evaluations (`njev`) and the number of
 |         LU decompositions (`nlu`).
 |      9. By convention the function evaluations used to compute a finite
 |         difference approximation of the Jacobian should not be counted in
 |         `nfev`, thus use `fun_single(self, t, y)` or
 |         `fun_vectorized(self, t, y)` when computing a finite difference
 |         approximation of the Jacobian.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar and there are two options for ndarray ``y``.
 |      It can either have shape (n,), then ``fun`` must return array_like with
 |      shape (n,). Or alternatively it can have shape (n, n_points), then
 |      ``fun`` must return array_like with shape (n, n_points) (each column
 |      corresponds to a single column in ``y``). The choice between the two
 |      options is determined by `vectorized` argument (see below).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time --- the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  vectorized : bool
 |      Whether `fun` is implemented in a vectorized fashion.
 |  support_complex : bool, optional
 |      Whether integration in a complex domain should be supported.
 |      Generally determined by a derived solver class capabilities.
 |      Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number of the system's rhs evaluations.
 |  njev : int
 |      Number of the Jacobian evaluations.
 |  nlu : int
 |      Number of LU decompositions.
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, vectorized, support_complex=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('(self, fun, t0, y0, t_bound, vectorized, support_complex=False)',)",scipy,1.1.0,scipy.integrate._ivp.base.OdeSolver,integrate._ivp.base,OdeSolver,"Python Library Documentation: class OdeSolver in module scipy.integrate._ivp.base

class OdeSolver(builtins.object)
 |  Base class for ODE solvers.
 |  
 |  In order to implement a new solver you need to follow the guidelines:
 |  
 |      1. A constructor must accept parameters presented in the base class
 |         (listed below) along with any other parameters specific to a solver.
 |      2. A constructor must accept arbitrary extraneous arguments
 |         ``**extraneous``, but warn that these arguments are irrelevant
 |         using `common.warn_extraneous` function. Do not pass these
 |         arguments to the base class.
 |      3. A solver must implement a private method `_step_impl(self)` which
 |         propagates a solver one step further. It must return tuple
 |         ``(success, message)``, where ``success`` is a boolean indicating
 |         whether a step was successful, and ``message`` is a string
 |         containing description of a failure if a step failed or None
 |         otherwise.
 |      4. A solver must implement a private method `_dense_output_impl(self)`
 |         which returns a `DenseOutput` object covering the last successful
 |         step.
 |      5. A solver must have attributes listed below in Attributes section.
 |         Note that `t_old` and `step_size` are updated automatically.
 |      6. Use `fun(self, t, y)` method for the system rhs evaluation, this
 |         way the number of function evaluations (`nfev`) will be tracked
 |         automatically.
 |      7. For convenience a base class provides `fun_single(self, t, y)` and
 |         `fun_vectorized(self, t, y)` for evaluating the rhs in
 |         non-vectorized and vectorized fashions respectively (regardless of
 |         how `fun` from the constructor is implemented). These calls don't
 |         increment `nfev`.
 |      8. If a solver uses a Jacobian matrix and LU decompositions, it should
 |         track the number of Jacobian evaluations (`njev`) and the number of
 |         LU decompositions (`nlu`).
 |      9. By convention the function evaluations used to compute a finite
 |         difference approximation of the Jacobian should not be counted in
 |         `nfev`, thus use `fun_single(self, t, y)` or
 |         `fun_vectorized(self, t, y)` when computing a finite difference
 |         approximation of the Jacobian.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar and there are two options for ndarray ``y``.
 |      It can either have shape (n,), then ``fun`` must return array_like with
 |      shape (n,). Or alternatively it can have shape (n, n_points), then
 |      ``fun`` must return array_like with shape (n, n_points) (each column
 |      corresponds to a single column in ``y``). The choice between the two
 |      options is determined by `vectorized` argument (see below).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time --- the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  vectorized : bool
 |      Whether `fun` is implemented in a vectorized fashion.
 |  support_complex : bool, optional
 |      Whether integration in a complex domain should be supported.
 |      Generally determined by a derived solver class capabilities.
 |      Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number of the system's rhs evaluations.
 |  njev : int
 |      Number of the Jacobian evaluations.
 |  nlu : int
 |      Number of LU decompositions.
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, vectorized, support_complex=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('self', 'fun', 't0', 'y0', 't_bound', 'vectorized', 'support_complex')","(nan, nan, nan, nan, nan, nan, False)","(nan, nan, nan, nan, nan, nan, 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, fun, t0, y0, t_bound, vectorized, support_complex=False)',)"
scipy,1.1.0,scipy.integrate._ivp.base.check_arguments,integrate._ivp.base,check_arguments,"Python Library Documentation: function check_arguments in module scipy.integrate._ivp.base

check_arguments(fun, y0, support_complex)
    Helper function for checking arguments common to all solvers.
",function,"('(fun, y0, support_complex)',)",scipy,1.1.0,scipy.integrate._ivp.base.check_arguments,integrate._ivp.base,check_arguments,"Python Library Documentation: function check_arguments in module scipy.integrate._ivp.base

check_arguments(fun, y0, support_complex)
    Helper function for checking arguments common to all solvers.
",function,"('fun', 'y0', 'support_complex')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(fun, y0, support_complex)',)"
scipy,1.1.0,scipy.integrate._ivp.bdf.BDF,integrate._ivp.bdf,BDF,"Python Library Documentation: class BDF in module scipy.integrate._ivp.bdf

class BDF(scipy.integrate._ivp.base.OdeSolver)
 |  Implicit method based on backward-differentiation formulas.
 |  
 |  This is a variable order method with the order varying automatically from
 |  1 to 5. The general framework of the BDF algorithm is described in [1]_.
 |  This class implements a quasi-constant step size as explained in [2]_.
 |  The error estimation strategy for the constant-step BDF is derived in [3]_.
 |  An accuracy enhancement using modified formulas (NDF) [2]_ is also implemented.
 |  
 |  Can be applied in the complex domain.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar, and there are two options for the ndarray ``y``:
 |      It can either have shape (n,); then ``fun`` must return array_like with
 |      shape (n,). Alternatively it can have shape (n, k); then ``fun``
 |      must return an array_like with shape (n, k), i.e. each column
 |      corresponds to a single column in ``y``. The choice between the two
 |      options is determined by `vectorized` argument (see below). The
 |      vectorized implementation allows a faster approximation of the Jacobian
 |      by finite differences (required for this solver).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time - the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  max_step : float, optional
 |      Maximum allowed step size. Default is np.inf, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  rtol, atol : float and array_like, optional
 |      Relative and absolute tolerances. The solver keeps the local error
 |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
 |      relative accuracy (number of correct digits). But if a component of `y`
 |      is approximately below `atol`, the error only needs to fall within
 |      the same `atol` threshold, and the number of correct digits is not
 |      guaranteed. If components of y have different scales, it might be
 |      beneficial to set different `atol` values for different components by
 |      passing array_like with shape (n,) for `atol`. Default values are
 |      1e-3 for `rtol` and 1e-6 for `atol`.
 |  jac : {None, array_like, sparse_matrix, callable}, optional
 |      Jacobian matrix of the right-hand side of the system with respect to y,
 |      required by this method. The Jacobian matrix has shape (n, n) and its
 |      element (i, j) is equal to ``d f_i / d y_j``.
 |      There are three ways to define the Jacobian:
 |  
 |          * If array_like or sparse_matrix, the Jacobian is assumed to
 |            be constant.
 |          * If callable, the Jacobian is assumed to depend on both
 |            t and y; it will be called as ``jac(t, y)`` as necessary.
 |            For the 'Radau' and 'BDF' methods, the return value might be a
 |            sparse matrix.
 |          * If None (default), the Jacobian will be approximated by
 |            finite differences.
 |  
 |      It is generally recommended to provide the Jacobian rather than
 |      relying on a finite-difference approximation.
 |  jac_sparsity : {None, array_like, sparse matrix}, optional
 |      Defines a sparsity structure of the Jacobian matrix for a
 |      finite-difference approximation. Its shape must be (n, n). This argument
 |      is ignored if `jac` is not `None`. If the Jacobian has only few non-zero
 |      elements in *each* row, providing the sparsity structure will greatly
 |      speed up the computations [4]_. A zero entry means that a corresponding
 |      element in the Jacobian is always zero. If None (default), the Jacobian
 |      is assumed to be dense.
 |  vectorized : bool, optional
 |      Whether `fun` is implemented in a vectorized fashion. Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number of evaluations of the right-hand side.
 |  njev : int
 |      Number of evaluations of the Jacobian.
 |  nlu : int
 |      Number of LU decompositions.
 |  
 |  References
 |  ----------
 |  .. [1] G. D. Byrne, A. C. Hindmarsh, ""A Polyalgorithm for the Numerical
 |         Solution of Ordinary Differential Equations"", ACM Transactions on
 |         Mathematical Software, Vol. 1, No. 1, pp. 71-96, March 1975.
 |  .. [2] L. F. Shampine, M. W. Reichelt, ""THE MATLAB ODE SUITE"", SIAM J. SCI.
 |         COMPUTE., Vol. 18, No. 1, pp. 1-22, January 1997.
 |  .. [3] E. Hairer, G. Wanner, ""Solving Ordinary Differential Equations I:
 |         Nonstiff Problems"", Sec. III.2.
 |  .. [4] A. Curtis, M. J. D. Powell, and J. Reid, ""On the estimation of
 |         sparse Jacobian matrices"", Journal of the Institute of Mathematics
 |         and its Applications, 13, pp. 117-120, 1974.
 |  
 |  Method resolution order:
 |      BDF
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, jac=None, jac_sparsity=None, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, jac=None, jac_sparsity=None, vectorized=False, **extraneous)',)",scipy,1.1.0,scipy.integrate._ivp.bdf.BDF,integrate._ivp.bdf,BDF,"Python Library Documentation: class BDF in module scipy.integrate._ivp.bdf

class BDF(scipy.integrate._ivp.base.OdeSolver)
 |  Implicit method based on backward-differentiation formulas.
 |  
 |  This is a variable order method with the order varying automatically from
 |  1 to 5. The general framework of the BDF algorithm is described in [1]_.
 |  This class implements a quasi-constant step size as explained in [2]_.
 |  The error estimation strategy for the constant-step BDF is derived in [3]_.
 |  An accuracy enhancement using modified formulas (NDF) [2]_ is also implemented.
 |  
 |  Can be applied in the complex domain.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar, and there are two options for the ndarray ``y``:
 |      It can either have shape (n,); then ``fun`` must return array_like with
 |      shape (n,). Alternatively it can have shape (n, k); then ``fun``
 |      must return an array_like with shape (n, k), i.e. each column
 |      corresponds to a single column in ``y``. The choice between the two
 |      options is determined by `vectorized` argument (see below). The
 |      vectorized implementation allows a faster approximation of the Jacobian
 |      by finite differences (required for this solver).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time - the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  max_step : float, optional
 |      Maximum allowed step size. Default is np.inf, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  rtol, atol : float and array_like, optional
 |      Relative and absolute tolerances. The solver keeps the local error
 |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
 |      relative accuracy (number of correct digits). But if a component of `y`
 |      is approximately below `atol`, the error only needs to fall within
 |      the same `atol` threshold, and the number of correct digits is not
 |      guaranteed. If components of y have different scales, it might be
 |      beneficial to set different `atol` values for different components by
 |      passing array_like with shape (n,) for `atol`. Default values are
 |      1e-3 for `rtol` and 1e-6 for `atol`.
 |  jac : {None, array_like, sparse_matrix, callable}, optional
 |      Jacobian matrix of the right-hand side of the system with respect to y,
 |      required by this method. The Jacobian matrix has shape (n, n) and its
 |      element (i, j) is equal to ``d f_i / d y_j``.
 |      There are three ways to define the Jacobian:
 |  
 |          * If array_like or sparse_matrix, the Jacobian is assumed to
 |            be constant.
 |          * If callable, the Jacobian is assumed to depend on both
 |            t and y; it will be called as ``jac(t, y)`` as necessary.
 |            For the 'Radau' and 'BDF' methods, the return value might be a
 |            sparse matrix.
 |          * If None (default), the Jacobian will be approximated by
 |            finite differences.
 |  
 |      It is generally recommended to provide the Jacobian rather than
 |      relying on a finite-difference approximation.
 |  jac_sparsity : {None, array_like, sparse matrix}, optional
 |      Defines a sparsity structure of the Jacobian matrix for a
 |      finite-difference approximation. Its shape must be (n, n). This argument
 |      is ignored if `jac` is not `None`. If the Jacobian has only few non-zero
 |      elements in *each* row, providing the sparsity structure will greatly
 |      speed up the computations [4]_. A zero entry means that a corresponding
 |      element in the Jacobian is always zero. If None (default), the Jacobian
 |      is assumed to be dense.
 |  vectorized : bool, optional
 |      Whether `fun` is implemented in a vectorized fashion. Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number of evaluations of the right-hand side.
 |  njev : int
 |      Number of evaluations of the Jacobian.
 |  nlu : int
 |      Number of LU decompositions.
 |  
 |  References
 |  ----------
 |  .. [1] G. D. Byrne, A. C. Hindmarsh, ""A Polyalgorithm for the Numerical
 |         Solution of Ordinary Differential Equations"", ACM Transactions on
 |         Mathematical Software, Vol. 1, No. 1, pp. 71-96, March 1975.
 |  .. [2] L. F. Shampine, M. W. Reichelt, ""THE MATLAB ODE SUITE"", SIAM J. SCI.
 |         COMPUTE., Vol. 18, No. 1, pp. 1-22, January 1997.
 |  .. [3] E. Hairer, G. Wanner, ""Solving Ordinary Differential Equations I:
 |         Nonstiff Problems"", Sec. III.2.
 |  .. [4] A. Curtis, M. J. D. Powell, and J. Reid, ""On the estimation of
 |         sparse Jacobian matrices"", Journal of the Institute of Mathematics
 |         and its Applications, 13, pp. 117-120, 1974.
 |  
 |  Method resolution order:
 |      BDF
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, jac=None, jac_sparsity=None, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('self', 'fun', 't0', 'y0', 't_bound', 'max_step', 'rtol', 'atol', 'jac', 'jac_sparsity', 'vectorized')","(nan, nan, nan, nan, nan, inf, 0.001, 1e-06, None, None, False)","(nan, nan, nan, nan, nan, 'float', 'float', 'float', 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, jac=None, jac_sparsity=None, vectorized=False, **extraneous)',)"
scipy,1.1.0,scipy.integrate._ivp.bdf.BdfDenseOutput,integrate._ivp.bdf,BdfDenseOutput,"Python Library Documentation: class BdfDenseOutput in module scipy.integrate._ivp.bdf

class BdfDenseOutput(scipy.integrate._ivp.base.DenseOutput)
 |  Base class for local interpolant over step made by an ODE solver.
 |  
 |  It interpolates between `t_min` and `t_max` (see Attributes below).
 |  Evaluation outside this interval is not forbidden, but the accuracy is not
 |  guaranteed.
 |  
 |  Attributes
 |  ----------
 |  t_min, t_max : float
 |      Time range of the interpolation.
 |  
 |  Method resolution order:
 |      BdfDenseOutput
 |      scipy.integrate._ivp.base.DenseOutput
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, t_old, t, h, order, D)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.DenseOutput:
 |  
 |  __call__(self, t)
 |      Evaluate the interpolant.
 |      
 |      Parameters
 |      ----------
 |      t : float or array_like with shape (n_points,)
 |          Points to evaluate the solution at.
 |      
 |      Returns
 |      -------
 |      y : ndarray, shape (n,) or (n, n_points)
 |          Computed values. Shape depends on whether `t` was a scalar or a
 |          1-d array.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.DenseOutput:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, t_old, t, h, order, D)',)",scipy,1.1.0,scipy.integrate._ivp.bdf.BdfDenseOutput,integrate._ivp.bdf,BdfDenseOutput,"Python Library Documentation: class BdfDenseOutput in module scipy.integrate._ivp.bdf

class BdfDenseOutput(scipy.integrate._ivp.base.DenseOutput)
 |  Base class for local interpolant over step made by an ODE solver.
 |  
 |  It interpolates between `t_min` and `t_max` (see Attributes below).
 |  Evaluation outside this interval is not forbidden, but the accuracy is not
 |  guaranteed.
 |  
 |  Attributes
 |  ----------
 |  t_min, t_max : float
 |      Time range of the interpolation.
 |  
 |  Method resolution order:
 |      BdfDenseOutput
 |      scipy.integrate._ivp.base.DenseOutput
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, t_old, t, h, order, D)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.DenseOutput:
 |  
 |  __call__(self, t)
 |      Evaluate the interpolant.
 |      
 |      Parameters
 |      ----------
 |      t : float or array_like with shape (n_points,)
 |          Points to evaluate the solution at.
 |      
 |      Returns
 |      -------
 |      y : ndarray, shape (n,) or (n, n_points)
 |          Computed values. Shape depends on whether `t` was a scalar or a
 |          1-d array.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.DenseOutput:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 't_old', 't', 'h', 'order', 'D')","(nan, nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, t_old, t, h, order, D)',)"
scipy,1.1.0,scipy.integrate._ivp.bdf.DenseOutput,integrate._ivp.bdf,DenseOutput,"Python Library Documentation: class DenseOutput in module scipy.integrate._ivp.base

class DenseOutput(builtins.object)
 |  Base class for local interpolant over step made by an ODE solver.
 |  
 |  It interpolates between `t_min` and `t_max` (see Attributes below).
 |  Evaluation outside this interval is not forbidden, but the accuracy is not
 |  guaranteed.
 |  
 |  Attributes
 |  ----------
 |  t_min, t_max : float
 |      Time range of the interpolation.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, t)
 |      Evaluate the interpolant.
 |      
 |      Parameters
 |      ----------
 |      t : float or array_like with shape (n_points,)
 |          Points to evaluate the solution at.
 |      
 |      Returns
 |      -------
 |      y : ndarray, shape (n,) or (n, n_points)
 |          Computed values. Shape depends on whether `t` was a scalar or a
 |          1-d array.
 |  
 |  __init__(self, t_old, t)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, t_old, t)',)",scipy,1.1.0,scipy.integrate._ivp.bdf.DenseOutput,integrate._ivp.bdf,DenseOutput,"Python Library Documentation: class DenseOutput in module scipy.integrate._ivp.base

class DenseOutput(builtins.object)
 |  Base class for local interpolant over step made by an ODE solver.
 |  
 |  It interpolates between `t_min` and `t_max` (see Attributes below).
 |  Evaluation outside this interval is not forbidden, but the accuracy is not
 |  guaranteed.
 |  
 |  Attributes
 |  ----------
 |  t_min, t_max : float
 |      Time range of the interpolation.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, t)
 |      Evaluate the interpolant.
 |      
 |      Parameters
 |      ----------
 |      t : float or array_like with shape (n_points,)
 |          Points to evaluate the solution at.
 |      
 |      Returns
 |      -------
 |      y : ndarray, shape (n,) or (n, n_points)
 |          Computed values. Shape depends on whether `t` was a scalar or a
 |          1-d array.
 |  
 |  __init__(self, t_old, t)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 't_old', 't')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(self, t_old, t)',)"
scipy,1.1.0,scipy.integrate._ivp.bdf.OdeSolver,integrate._ivp.bdf,OdeSolver,"Python Library Documentation: class OdeSolver in module scipy.integrate._ivp.base

class OdeSolver(builtins.object)
 |  Base class for ODE solvers.
 |  
 |  In order to implement a new solver you need to follow the guidelines:
 |  
 |      1. A constructor must accept parameters presented in the base class
 |         (listed below) along with any other parameters specific to a solver.
 |      2. A constructor must accept arbitrary extraneous arguments
 |         ``**extraneous``, but warn that these arguments are irrelevant
 |         using `common.warn_extraneous` function. Do not pass these
 |         arguments to the base class.
 |      3. A solver must implement a private method `_step_impl(self)` which
 |         propagates a solver one step further. It must return tuple
 |         ``(success, message)``, where ``success`` is a boolean indicating
 |         whether a step was successful, and ``message`` is a string
 |         containing description of a failure if a step failed or None
 |         otherwise.
 |      4. A solver must implement a private method `_dense_output_impl(self)`
 |         which returns a `DenseOutput` object covering the last successful
 |         step.
 |      5. A solver must have attributes listed below in Attributes section.
 |         Note that `t_old` and `step_size` are updated automatically.
 |      6. Use `fun(self, t, y)` method for the system rhs evaluation, this
 |         way the number of function evaluations (`nfev`) will be tracked
 |         automatically.
 |      7. For convenience a base class provides `fun_single(self, t, y)` and
 |         `fun_vectorized(self, t, y)` for evaluating the rhs in
 |         non-vectorized and vectorized fashions respectively (regardless of
 |         how `fun` from the constructor is implemented). These calls don't
 |         increment `nfev`.
 |      8. If a solver uses a Jacobian matrix and LU decompositions, it should
 |         track the number of Jacobian evaluations (`njev`) and the number of
 |         LU decompositions (`nlu`).
 |      9. By convention the function evaluations used to compute a finite
 |         difference approximation of the Jacobian should not be counted in
 |         `nfev`, thus use `fun_single(self, t, y)` or
 |         `fun_vectorized(self, t, y)` when computing a finite difference
 |         approximation of the Jacobian.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar and there are two options for ndarray ``y``.
 |      It can either have shape (n,), then ``fun`` must return array_like with
 |      shape (n,). Or alternatively it can have shape (n, n_points), then
 |      ``fun`` must return array_like with shape (n, n_points) (each column
 |      corresponds to a single column in ``y``). The choice between the two
 |      options is determined by `vectorized` argument (see below).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time --- the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  vectorized : bool
 |      Whether `fun` is implemented in a vectorized fashion.
 |  support_complex : bool, optional
 |      Whether integration in a complex domain should be supported.
 |      Generally determined by a derived solver class capabilities.
 |      Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number of the system's rhs evaluations.
 |  njev : int
 |      Number of the Jacobian evaluations.
 |  nlu : int
 |      Number of LU decompositions.
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, vectorized, support_complex=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('(self, fun, t0, y0, t_bound, vectorized, support_complex=False)',)",scipy,1.1.0,scipy.integrate._ivp.bdf.OdeSolver,integrate._ivp.bdf,OdeSolver,"Python Library Documentation: class OdeSolver in module scipy.integrate._ivp.base

class OdeSolver(builtins.object)
 |  Base class for ODE solvers.
 |  
 |  In order to implement a new solver you need to follow the guidelines:
 |  
 |      1. A constructor must accept parameters presented in the base class
 |         (listed below) along with any other parameters specific to a solver.
 |      2. A constructor must accept arbitrary extraneous arguments
 |         ``**extraneous``, but warn that these arguments are irrelevant
 |         using `common.warn_extraneous` function. Do not pass these
 |         arguments to the base class.
 |      3. A solver must implement a private method `_step_impl(self)` which
 |         propagates a solver one step further. It must return tuple
 |         ``(success, message)``, where ``success`` is a boolean indicating
 |         whether a step was successful, and ``message`` is a string
 |         containing description of a failure if a step failed or None
 |         otherwise.
 |      4. A solver must implement a private method `_dense_output_impl(self)`
 |         which returns a `DenseOutput` object covering the last successful
 |         step.
 |      5. A solver must have attributes listed below in Attributes section.
 |         Note that `t_old` and `step_size` are updated automatically.
 |      6. Use `fun(self, t, y)` method for the system rhs evaluation, this
 |         way the number of function evaluations (`nfev`) will be tracked
 |         automatically.
 |      7. For convenience a base class provides `fun_single(self, t, y)` and
 |         `fun_vectorized(self, t, y)` for evaluating the rhs in
 |         non-vectorized and vectorized fashions respectively (regardless of
 |         how `fun` from the constructor is implemented). These calls don't
 |         increment `nfev`.
 |      8. If a solver uses a Jacobian matrix and LU decompositions, it should
 |         track the number of Jacobian evaluations (`njev`) and the number of
 |         LU decompositions (`nlu`).
 |      9. By convention the function evaluations used to compute a finite
 |         difference approximation of the Jacobian should not be counted in
 |         `nfev`, thus use `fun_single(self, t, y)` or
 |         `fun_vectorized(self, t, y)` when computing a finite difference
 |         approximation of the Jacobian.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar and there are two options for ndarray ``y``.
 |      It can either have shape (n,), then ``fun`` must return array_like with
 |      shape (n,). Or alternatively it can have shape (n, n_points), then
 |      ``fun`` must return array_like with shape (n, n_points) (each column
 |      corresponds to a single column in ``y``). The choice between the two
 |      options is determined by `vectorized` argument (see below).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time --- the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  vectorized : bool
 |      Whether `fun` is implemented in a vectorized fashion.
 |  support_complex : bool, optional
 |      Whether integration in a complex domain should be supported.
 |      Generally determined by a derived solver class capabilities.
 |      Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number of the system's rhs evaluations.
 |  njev : int
 |      Number of the Jacobian evaluations.
 |  nlu : int
 |      Number of LU decompositions.
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, vectorized, support_complex=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('self', 'fun', 't0', 'y0', 't_bound', 'vectorized', 'support_complex')","(nan, nan, nan, nan, nan, nan, False)","(nan, nan, nan, nan, nan, nan, 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, fun, t0, y0, t_bound, vectorized, support_complex=False)',)"
scipy,1.1.0,scipy.integrate._ivp.bdf.change_D,integrate._ivp.bdf,change_D,"Python Library Documentation: function change_D in module scipy.integrate._ivp.bdf

change_D(D, order, factor)
    Change differences array in-place when step size is changed.
",function,"('(D, order, factor)',)",scipy,1.1.0,scipy.integrate._ivp.bdf.change_D,integrate._ivp.bdf,change_D,"Python Library Documentation: function change_D in module scipy.integrate._ivp.bdf

change_D(D, order, factor)
    Change differences array in-place when step size is changed.
",function,"('D', 'order', 'factor')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(D, order, factor)',)"
scipy,1.1.0,scipy.integrate._ivp.bdf.compute_R,integrate._ivp.bdf,compute_R,"Python Library Documentation: function compute_R in module scipy.integrate._ivp.bdf

compute_R(order, factor)
    Compute the matrix for changing the differences array.
",function,"('(order, factor)',)",scipy,1.1.0,scipy.integrate._ivp.bdf.compute_R,integrate._ivp.bdf,compute_R,"Python Library Documentation: function compute_R in module scipy.integrate._ivp.bdf

compute_R(order, factor)
    Compute the matrix for changing the differences array.
",function,"('order', 'factor')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(order, factor)',)"
scipy,1.1.0,scipy.integrate._ivp.bdf.csc_matrix,integrate._ivp.bdf,csc_matrix,"Python Library Documentation: class csc_matrix in module scipy.sparse.csc

class csc_matrix(scipy.sparse.compressed._cs_matrix, scipy.sparse.sputils.IndexMixin)
 |  Compressed Sparse Column matrix
 |  
 |  This can be instantiated in several ways:
 |  
 |      csc_matrix(D)
 |          with a dense matrix or rank-2 ndarray D
 |  
 |      csc_matrix(S)
 |          with another sparse matrix S (equivalent to S.tocsc())
 |  
 |      csc_matrix((M, N), [dtype])
 |          to construct an empty matrix with shape (M, N)
 |          dtype is optional, defaulting to dtype='d'.
 |  
 |      csc_matrix((data, (row_ind, col_ind)), [shape=(M, N)])
 |          where ``data``, ``row_ind`` and ``col_ind`` satisfy the
 |          relationship ``a[row_ind[k], col_ind[k]] = data[k]``.
 |  
 |      csc_matrix((data, indices, indptr), [shape=(M, N)])
 |          is the standard CSC representation where the row indices for
 |          column i are stored in ``indices[indptr[i]:indptr[i+1]]``
 |          and their corresponding values are stored in
 |          ``data[indptr[i]:indptr[i+1]]``.  If the shape parameter is
 |          not supplied, the matrix dimensions are inferred from
 |          the index arrays.
 |  
 |  Attributes
 |  ----------
 |  dtype : dtype
 |      Data type of the matrix
 |  shape : 2-tuple
 |      Shape of the matrix
 |  ndim : int
 |      Number of dimensions (this is always 2)
 |  nnz
 |      Number of nonzero elements
 |  data
 |      Data array of the matrix
 |  indices
 |      CSC format index array
 |  indptr
 |      CSC format index pointer array
 |  has_sorted_indices
 |      Whether indices are sorted
 |  
 |  Notes
 |  -----
 |  
 |  Sparse matrices can be used in arithmetic operations: they support
 |  addition, subtraction, multiplication, division, and matrix power.
 |  
 |  Advantages of the CSC format
 |      - efficient arithmetic operations CSC + CSC, CSC * CSC, etc.
 |      - efficient column slicing
 |      - fast matrix vector products (CSR, BSR may be faster)
 |  
 |  Disadvantages of the CSC format
 |    - slow row slicing operations (consider CSR)
 |    - changes to the sparsity structure are expensive (consider LIL or DOK)
 |  
 |  
 |  Examples
 |  --------
 |  
 |  >>> import numpy as np
 |  >>> from scipy.sparse import csc_matrix
 |  >>> csc_matrix((3, 4), dtype=np.int8).toarray()
 |  array([[0, 0, 0, 0],
 |         [0, 0, 0, 0],
 |         [0, 0, 0, 0]], dtype=int8)
 |  
 |  >>> row = np.array([0, 2, 2, 0, 1, 2])
 |  >>> col = np.array([0, 0, 1, 2, 2, 2])
 |  >>> data = np.array([1, 2, 3, 4, 5, 6])
 |  >>> csc_matrix((data, (row, col)), shape=(3, 3)).toarray()
 |  array([[1, 0, 4],
 |         [0, 0, 5],
 |         [2, 3, 6]])
 |  
 |  >>> indptr = np.array([0, 2, 3, 6])
 |  >>> indices = np.array([0, 2, 2, 0, 1, 2])
 |  >>> data = np.array([1, 2, 3, 4, 5, 6])
 |  >>> csc_matrix((data, indices, indptr), shape=(3, 3)).toarray()
 |  array([[1, 0, 4],
 |         [0, 0, 5],
 |         [2, 3, 6]])
 |  
 |  Method resolution order:
 |      csc_matrix
 |      scipy.sparse.compressed._cs_matrix
 |      scipy.sparse.data._data_matrix
 |      scipy.sparse.base.spmatrix
 |      scipy.sparse.data._minmax_mixin
 |      scipy.sparse.sputils.IndexMixin
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __getitem__(self, key)
 |  
 |  __iter__(self)
 |  
 |  getcol(self, i)
 |      Returns a copy of column i of the matrix, as a (m x 1)
 |      CSC matrix (column vector).
 |  
 |  getrow(self, i)
 |      Returns a copy of row i of the matrix, as a (1 x n)
 |      CSR matrix (row vector).
 |  
 |  nonzero(self)
 |      nonzero indices
 |      
 |      Returns a tuple of arrays (row,col) containing the indices
 |      of the non-zero elements of the matrix.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1,2,0],[0,0,3],[4,0,5]])
 |      >>> A.nonzero()
 |      (array([0, 0, 1, 2, 2]), array([0, 1, 2, 0, 2]))
 |  
 |  tocsc(self, copy=False)
 |      Convert this matrix to Compressed Sparse Column format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant csc_matrix.
 |  
 |  tocsr(self, copy=False)
 |      Convert this matrix to Compressed Sparse Row format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant csr_matrix.
 |  
 |  transpose(self, axes=None, copy=False)
 |      Reverses the dimensions of the sparse matrix.
 |      
 |      Parameters
 |      ----------
 |      axes : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value.
 |      copy : bool, optional
 |          Indicates whether or not attributes of `self` should be
 |          copied whenever possible. The degree to which attributes
 |          are copied varies depending on the type of sparse matrix
 |          being used.
 |      
 |      Returns
 |      -------
 |      p : `self` with the dimensions reversed.
 |      
 |      See Also
 |      --------
 |      np.matrix.transpose : NumPy's implementation of 'transpose'
 |                            for matrices
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  format = 'csc'
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.compressed._cs_matrix:
 |  
 |  __eq__(self, other)
 |      Return self==value.
 |  
 |  __ge__(self, other)
 |      Return self>=value.
 |  
 |  __gt__(self, other)
 |      Return self>value.
 |  
 |  __init__(self, arg1, shape=None, dtype=None, copy=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __le__(self, other)
 |      Return self<=value.
 |  
 |  __lt__(self, other)
 |      Return self<value.
 |  
 |  __ne__(self, other)
 |      Return self!=value.
 |  
 |  __setitem__(self, index, x)
 |  
 |  check_format(self, full_check=True)
 |      check whether the matrix format is valid
 |      
 |      Parameters
 |      ----------
 |      full_check : bool, optional
 |          If `True`, rigorous check, O(N) operations. Otherwise
 |          basic check, O(1) operations (default True).
 |  
 |  diagonal(self, k=0)
 |      Returns the k-th diagonal of the matrix.
 |      
 |      Parameters
 |      ----------
 |      k : int, optional
 |          Which diagonal to set, corresponding to elements a[i, i+k].
 |          Default: 0 (the main diagonal).
 |      
 |          .. versionadded:: 1.0
 |      
 |      See also
 |      --------
 |      numpy.diagonal : Equivalent numpy function.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> A.diagonal()
 |      array([1, 0, 5])
 |      >>> A.diagonal(k=1)
 |      array([2, 3])
 |  
 |  eliminate_zeros(self)
 |      Remove zero entries from the matrix
 |      
 |      This is an *in place* operation
 |  
 |  getnnz(self, axis=None)
 |      Number of stored values, including explicit zeros.
 |      
 |      Parameters
 |      ----------
 |      axis : None, 0, or 1
 |          Select between the number of values across the whole matrix, in
 |          each column, or in each row.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  maximum(self, other)
 |      Element-wise maximum between this and another matrix.
 |  
 |  minimum(self, other)
 |      Element-wise minimum between this and another matrix.
 |  
 |  multiply(self, other)
 |      Point-wise multiplication by another matrix, vector, or
 |      scalar.
 |  
 |  prune(self)
 |      Remove empty space after all non-zero elements.
 |  
 |  resize(self, *shape)
 |      Resize the matrix in-place to dimensions given by ``shape``
 |      
 |      Any elements that lie within the new shape will remain at the same
 |      indices, while non-zero elements lying outside the new shape are
 |      removed.
 |      
 |      Parameters
 |      ----------
 |      shape : (int, int)
 |          number of rows and columns in the new matrix
 |      
 |      Notes
 |      -----
 |      The semantics are not identical to `numpy.ndarray.resize` or
 |      `numpy.resize`.  Here, the same data will be maintained at each index
 |      before and after reshape, if that index is within the new bounds.  In
 |      numpy, resizing maintains contiguity of the array, moving elements
 |      around in the logical matrix but not within a flattened representation.
 |      
 |      We give no guarantees about whether the underlying data attributes
 |      (arrays, etc.) will be modified in place or replaced with new objects.
 |  
 |  sort_indices(self)
 |      Sort the indices of this matrix *in place*
 |  
 |  sorted_indices(self)
 |      Return a copy of this matrix with sorted indices
 |  
 |  sum(self, axis=None, dtype=None, out=None)
 |      Sum the matrix elements over a given axis.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the sum of all the matrix elements, returning a scalar
 |          (i.e. `axis` = `None`).
 |      dtype : dtype, optional
 |          The type of the returned matrix and of the accumulator in which
 |          the elements are summed.  The dtype of `a` is used by default
 |          unless `a` has an integer dtype of less precision than the default
 |          platform integer.  In that case, if `a` is signed then the platform
 |          integer is used while if `a` is unsigned then an unsigned integer
 |          of the same precision as the platform integer is used.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      sum_along_axis : np.matrix
 |          A matrix with the same shape as `self`, with the specified
 |          axis removed.
 |      
 |      See Also
 |      --------
 |      np.matrix.sum : NumPy's implementation of 'sum' for matrices
 |  
 |  sum_duplicates(self)
 |      Eliminate duplicate matrix entries by adding them together
 |      
 |      The is an *in place* operation
 |  
 |  toarray(self, order=None, out=None)
 |      Return a dense ndarray representation of this matrix.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F'}, optional
 |          Whether to store multi-dimensional data in C (row-major)
 |          or Fortran (column-major) order in memory. The default
 |          is 'None', indicating the NumPy default of C-ordered.
 |          Cannot be specified in conjunction with the `out`
 |          argument.
 |      
 |      out : ndarray, 2-dimensional, optional
 |          If specified, uses this array as the output buffer
 |          instead of allocating a new array to return. The provided
 |          array must have the same shape and dtype as the sparse
 |          matrix on which you are calling the method. For most
 |          sparse types, `out` is required to be memory contiguous
 |          (either C or Fortran ordered).
 |      
 |      Returns
 |      -------
 |      arr : ndarray, 2-dimensional
 |          An array with the same shape and containing the same
 |          data represented by the sparse matrix, with the requested
 |          memory order. If `out` was passed, the same object is
 |          returned after being modified in-place to contain the
 |          appropriate values.
 |  
 |  tocoo(self, copy=True)
 |      Convert this matrix to COOrdinate format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant coo_matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.compressed._cs_matrix:
 |  
 |  has_canonical_format
 |      Determine whether the matrix has sorted indices and no duplicates
 |      
 |      Returns
 |          - True: if the above applies
 |          - False: otherwise
 |      
 |      has_canonical_format implies has_sorted_indices, so if the latter flag
 |      is False, so will the former be; if the former is found True, the
 |      latter flag is also set.
 |  
 |  has_sorted_indices
 |      Determine whether the matrix has sorted indices
 |      
 |      Returns
 |          - True: if the indices of the matrix are in sorted order
 |          - False: otherwise
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.sparse.compressed._cs_matrix:
 |  
 |  __hash__ = None
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._data_matrix:
 |  
 |  __abs__(self)
 |  
 |  __imul__(self, other)
 |  
 |  __itruediv__(self, other)
 |  
 |  __neg__(self)
 |  
 |  arcsin(self)
 |      Element-wise arcsin.
 |      
 |      See numpy.arcsin for more information.
 |  
 |  arcsinh(self)
 |      Element-wise arcsinh.
 |      
 |      See numpy.arcsinh for more information.
 |  
 |  arctan(self)
 |      Element-wise arctan.
 |      
 |      See numpy.arctan for more information.
 |  
 |  arctanh(self)
 |      Element-wise arctanh.
 |      
 |      See numpy.arctanh for more information.
 |  
 |  astype(self, dtype, casting='unsafe', copy=True)
 |      Cast the matrix elements to a specified type.
 |      
 |      Parameters
 |      ----------
 |      dtype : string or numpy dtype
 |          Typecode or data-type to which to cast the data.
 |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
 |          Controls what kind of data casting may occur.
 |          Defaults to 'unsafe' for backwards compatibility.
 |          'no' means the data types should not be cast at all.
 |          'equiv' means only byte-order changes are allowed.
 |          'safe' means only casts which can preserve values are allowed.
 |          'same_kind' means only safe casts or casts within a kind,
 |          like float64 to float32, are allowed.
 |          'unsafe' means any data conversions may be done.
 |      copy : bool, optional
 |          If `copy` is `False`, the result might share some memory with this
 |          matrix. If `copy` is `True`, it is guaranteed that the result and
 |          this matrix do not share any memory.
 |  
 |  ceil(self)
 |      Element-wise ceil.
 |      
 |      See numpy.ceil for more information.
 |  
 |  conj(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  copy(self)
 |      Returns a copy of this matrix.
 |      
 |      No data/indices will be shared between the returned value and current
 |      matrix.
 |  
 |  count_nonzero(self)
 |      Number of non-zero entries, equivalent to
 |      
 |      np.count_nonzero(a.toarray())
 |      
 |      Unlike getnnz() and the nnz property, which return the number of stored
 |      entries (the length of the data attribute), this method counts the
 |      actual number of non-zero entries in data.
 |  
 |  deg2rad(self)
 |      Element-wise deg2rad.
 |      
 |      See numpy.deg2rad for more information.
 |  
 |  expm1(self)
 |      Element-wise expm1.
 |      
 |      See numpy.expm1 for more information.
 |  
 |  floor(self)
 |      Element-wise floor.
 |      
 |      See numpy.floor for more information.
 |  
 |  log1p(self)
 |      Element-wise log1p.
 |      
 |      See numpy.log1p for more information.
 |  
 |  power(self, n, dtype=None)
 |      This function performs element-wise power.
 |      
 |      Parameters
 |      ----------
 |      n : n is a scalar
 |      
 |      dtype : If dtype is not specified, the current dtype will be preserved.
 |  
 |  rad2deg(self)
 |      Element-wise rad2deg.
 |      
 |      See numpy.rad2deg for more information.
 |  
 |  rint(self)
 |      Element-wise rint.
 |      
 |      See numpy.rint for more information.
 |  
 |  sign(self)
 |      Element-wise sign.
 |      
 |      See numpy.sign for more information.
 |  
 |  sin(self)
 |      Element-wise sin.
 |      
 |      See numpy.sin for more information.
 |  
 |  sinh(self)
 |      Element-wise sinh.
 |      
 |      See numpy.sinh for more information.
 |  
 |  sqrt(self)
 |      Element-wise sqrt.
 |      
 |      See numpy.sqrt for more information.
 |  
 |  tan(self)
 |      Element-wise tan.
 |      
 |      See numpy.tan for more information.
 |  
 |  tanh(self)
 |      Element-wise tanh.
 |      
 |      See numpy.tanh for more information.
 |  
 |  trunc(self)
 |      Element-wise trunc.
 |      
 |      See numpy.trunc for more information.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.data._data_matrix:
 |  
 |  dtype
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.base.spmatrix:
 |  
 |  __add__(self, other)
 |  
 |  __bool__(self)
 |  
 |  __div__(self, other)
 |  
 |  __getattr__(self, attr)
 |  
 |  __iadd__(self, other)
 |  
 |  __idiv__(self, other)
 |  
 |  __isub__(self, other)
 |  
 |  __len__(self)
 |      # What should len(sparse) return? For consistency with dense matrices,
 |      # perhaps it should be the number of rows?  But for some uses the number of
 |      # non-zeros is more important.  For now, raise an exception!
 |  
 |  __matmul__(self, other)
 |  
 |  __mul__(self, other)
 |      interpret other and call one of the following
 |      
 |      self._mul_scalar()
 |      self._mul_vector()
 |      self._mul_multivector()
 |      self._mul_sparse_matrix()
 |  
 |  __nonzero__ = __bool__(self)
 |  
 |  __pow__(self, other)
 |  
 |  __radd__(self, other)
 |  
 |  __rdiv__(self, other)
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __rmatmul__(self, other)
 |  
 |  __rmul__(self, other)
 |  
 |  __rsub__(self, other)
 |  
 |  __rtruediv__(self, other)
 |  
 |  __str__(self)
 |      Return str(self).
 |  
 |  __sub__(self, other)
 |  
 |  __truediv__(self, other)
 |  
 |  asformat(self, format, copy=False)
 |      Return this matrix in the passed sparse format.
 |      
 |      Parameters
 |      ----------
 |      format : {str, None}
 |          The desired sparse matrix format (""csr"", ""csc"", ""lil"", ""dok"", ...)
 |          or None for no conversion.
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : This matrix in the passed sparse format.
 |  
 |  asfptype(self)
 |      Upcast matrix to a floating point format (if necessary)
 |  
 |  conjugate(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  dot(self, other)
 |      Ordinary dot product
 |      
 |      Examples
 |      --------
 |      >>> import numpy as np
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> v = np.array([1, 0, -1])
 |      >>> A.dot(v)
 |      array([ 1, -3, -1], dtype=int64)
 |  
 |  getH(self)
 |      Return the Hermitian transpose of this matrix.
 |      
 |      See Also
 |      --------
 |      np.matrix.getH : NumPy's implementation of `getH` for matrices
 |  
 |  get_shape(self)
 |      Get shape of a matrix.
 |  
 |  getformat(self)
 |      Format of a matrix representation as a string.
 |  
 |  getmaxprint(self)
 |      Maximum number of elements to display when printed.
 |  
 |  mean(self, axis=None, dtype=None, out=None)
 |      Compute the arithmetic mean along the specified axis.
 |      
 |      Returns the average of the matrix elements. The average is taken
 |      over all elements in the matrix by default, otherwise over the
 |      specified axis. `float64` intermediate and return values are used
 |      for integer inputs.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the mean is computed. The default is to compute
 |          the mean of all elements in the matrix (i.e. `axis` = `None`).
 |      dtype : data-type, optional
 |          Type to use in computing the mean. For integer inputs, the default
 |          is `float64`; for floating point inputs, it is the same as the
 |          input dtype.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      m : np.matrix
 |      
 |      See Also
 |      --------
 |      np.matrix.mean : NumPy's implementation of 'mean' for matrices
 |  
 |  reshape(self, *args, **kwargs)
 |      reshape(self, shape, order='C', copy=False)
 |      
 |      Gives a new shape to a sparse matrix without changing its data.
 |      
 |      Parameters
 |      ----------
 |      shape : length-2 tuple of ints
 |          The new shape should be compatible with the original shape.
 |      order : {'C', 'F'}, optional
 |          Read the elements using this index order. 'C' means to read and
 |          write the elements using C-like index order; e.g. read entire first
 |          row, then second row, etc. 'F' means to read and write the elements
 |          using Fortran-like index order; e.g. read entire first column, then
 |          second column, etc.
 |      copy : bool, optional
 |          Indicates whether or not attributes of self should be copied
 |          whenever possible. The degree to which attributes are copied varies
 |          depending on the type of sparse matrix being used.
 |      
 |      Returns
 |      -------
 |      reshaped_matrix : sparse matrix
 |          A sparse matrix with the given `shape`, not necessarily of the same
 |          format as the current object.
 |      
 |      See Also
 |      --------
 |      np.matrix.reshape : NumPy's implementation of 'reshape' for matrices
 |  
 |  set_shape(self, shape)
 |      See `reshape`.
 |  
 |  setdiag(self, values, k=0)
 |      Set diagonal or off-diagonal elements of the array.
 |      
 |      Parameters
 |      ----------
 |      values : array_like
 |          New values of the diagonal elements.
 |      
 |          Values may have any length.  If the diagonal is longer than values,
 |          then the remaining diagonal entries will not be set.  If values if
 |          longer than the diagonal, then the remaining values are ignored.
 |      
 |          If a scalar value is given, all of the diagonal is set to it.
 |      
 |      k : int, optional
 |          Which off-diagonal to set, corresponding to elements a[i,i+k].
 |          Default: 0 (the main diagonal).
 |  
 |  tobsr(self, blocksize=None, copy=False)
 |      Convert this matrix to Block Sparse Row format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant bsr_matrix.
 |      
 |      When blocksize=(R, C) is provided, it will be used for construction of
 |      the bsr_matrix.
 |  
 |  todense(self, order=None, out=None)
 |      Return a dense matrix representation of this matrix.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F'}, optional
 |          Whether to store multi-dimensional data in C (row-major)
 |          or Fortran (column-major) order in memory. The default
 |          is 'None', indicating the NumPy default of C-ordered.
 |          Cannot be specified in conjunction with the `out`
 |          argument.
 |      
 |      out : ndarray, 2-dimensional, optional
 |          If specified, uses this array (or `numpy.matrix`) as the
 |          output buffer instead of allocating a new array to
 |          return. The provided array must have the same shape and
 |          dtype as the sparse matrix on which you are calling the
 |          method.
 |      
 |      Returns
 |      -------
 |      arr : numpy.matrix, 2-dimensional
 |          A NumPy matrix object with the same shape and containing
 |          the same data represented by the sparse matrix, with the
 |          requested memory order. If `out` was passed and was an
 |          array (rather than a `numpy.matrix`), it will be filled
 |          with the appropriate values and returned wrapped in a
 |          `numpy.matrix` object that shares the same memory.
 |  
 |  todia(self, copy=False)
 |      Convert this matrix to sparse DIAgonal format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dia_matrix.
 |  
 |  todok(self, copy=False)
 |      Convert this matrix to Dictionary Of Keys format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dok_matrix.
 |  
 |  tolil(self, copy=False)
 |      Convert this matrix to LInked List format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant lil_matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.base.spmatrix:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  nnz
 |      Number of stored values, including explicit zeros.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  shape
 |      Get shape of a matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.sparse.base.spmatrix:
 |  
 |  __array_priority__ = 10.1
 |  
 |  ndim = 2
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._minmax_mixin:
 |  
 |  argmax(self, axis=None, out=None)
 |      Return indices of maximum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several maximum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmax is computed. If None (default), index
 |          of the maximum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      ind : np.matrix or int
 |          Indices of maximum elements. If matrix, its size along `axis` is 1.
 |  
 |  argmin(self, axis=None, out=None)
 |      Return indices of minimum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several minimum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmin is computed. If None (default), index
 |          of the minimum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |       ind : np.matrix or int
 |          Indices of minimum elements. If matrix, its size along `axis` is 1.
 |  
 |  max(self, axis=None, out=None)
 |      Return the maximum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the maximum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amax : coo_matrix or scalar
 |          Maximum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      min : The minimum value of a sparse matrix along a given axis.
 |      np.matrix.max : NumPy's implementation of 'max' for matrices
 |  
 |  min(self, axis=None, out=None)
 |      Return the minimum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the minimum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amin : coo_matrix or scalar
 |          Minimum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      max : The maximum value of a sparse matrix along a given axis.
 |      np.matrix.min : NumPy's implementation of 'min' for matrices
",class,"('(self, arg1, shape=None, dtype=None, copy=False)',)",scipy,1.1.0,scipy.integrate._ivp.bdf.csc_matrix,integrate._ivp.bdf,csc_matrix,"Python Library Documentation: class csc_matrix in module scipy.sparse.csc

class csc_matrix(scipy.sparse.compressed._cs_matrix, scipy.sparse.sputils.IndexMixin)
 |  Compressed Sparse Column matrix
 |  
 |  This can be instantiated in several ways:
 |  
 |      csc_matrix(D)
 |          with a dense matrix or rank-2 ndarray D
 |  
 |      csc_matrix(S)
 |          with another sparse matrix S (equivalent to S.tocsc())
 |  
 |      csc_matrix((M, N), [dtype])
 |          to construct an empty matrix with shape (M, N)
 |          dtype is optional, defaulting to dtype='d'.
 |  
 |      csc_matrix((data, (row_ind, col_ind)), [shape=(M, N)])
 |          where ``data``, ``row_ind`` and ``col_ind`` satisfy the
 |          relationship ``a[row_ind[k], col_ind[k]] = data[k]``.
 |  
 |      csc_matrix((data, indices, indptr), [shape=(M, N)])
 |          is the standard CSC representation where the row indices for
 |          column i are stored in ``indices[indptr[i]:indptr[i+1]]``
 |          and their corresponding values are stored in
 |          ``data[indptr[i]:indptr[i+1]]``.  If the shape parameter is
 |          not supplied, the matrix dimensions are inferred from
 |          the index arrays.
 |  
 |  Attributes
 |  ----------
 |  dtype : dtype
 |      Data type of the matrix
 |  shape : 2-tuple
 |      Shape of the matrix
 |  ndim : int
 |      Number of dimensions (this is always 2)
 |  nnz
 |      Number of nonzero elements
 |  data
 |      Data array of the matrix
 |  indices
 |      CSC format index array
 |  indptr
 |      CSC format index pointer array
 |  has_sorted_indices
 |      Whether indices are sorted
 |  
 |  Notes
 |  -----
 |  
 |  Sparse matrices can be used in arithmetic operations: they support
 |  addition, subtraction, multiplication, division, and matrix power.
 |  
 |  Advantages of the CSC format
 |      - efficient arithmetic operations CSC + CSC, CSC * CSC, etc.
 |      - efficient column slicing
 |      - fast matrix vector products (CSR, BSR may be faster)
 |  
 |  Disadvantages of the CSC format
 |    - slow row slicing operations (consider CSR)
 |    - changes to the sparsity structure are expensive (consider LIL or DOK)
 |  
 |  
 |  Examples
 |  --------
 |  
 |  >>> import numpy as np
 |  >>> from scipy.sparse import csc_matrix
 |  >>> csc_matrix((3, 4), dtype=np.int8).toarray()
 |  array([[0, 0, 0, 0],
 |         [0, 0, 0, 0],
 |         [0, 0, 0, 0]], dtype=int8)
 |  
 |  >>> row = np.array([0, 2, 2, 0, 1, 2])
 |  >>> col = np.array([0, 0, 1, 2, 2, 2])
 |  >>> data = np.array([1, 2, 3, 4, 5, 6])
 |  >>> csc_matrix((data, (row, col)), shape=(3, 3)).toarray()
 |  array([[1, 0, 4],
 |         [0, 0, 5],
 |         [2, 3, 6]])
 |  
 |  >>> indptr = np.array([0, 2, 3, 6])
 |  >>> indices = np.array([0, 2, 2, 0, 1, 2])
 |  >>> data = np.array([1, 2, 3, 4, 5, 6])
 |  >>> csc_matrix((data, indices, indptr), shape=(3, 3)).toarray()
 |  array([[1, 0, 4],
 |         [0, 0, 5],
 |         [2, 3, 6]])
 |  
 |  Method resolution order:
 |      csc_matrix
 |      scipy.sparse.compressed._cs_matrix
 |      scipy.sparse.data._data_matrix
 |      scipy.sparse.base.spmatrix
 |      scipy.sparse.data._minmax_mixin
 |      scipy.sparse.sputils.IndexMixin
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __getitem__(self, key)
 |  
 |  __iter__(self)
 |  
 |  getcol(self, i)
 |      Returns a copy of column i of the matrix, as a (m x 1)
 |      CSC matrix (column vector).
 |  
 |  getrow(self, i)
 |      Returns a copy of row i of the matrix, as a (1 x n)
 |      CSR matrix (row vector).
 |  
 |  nonzero(self)
 |      nonzero indices
 |      
 |      Returns a tuple of arrays (row,col) containing the indices
 |      of the non-zero elements of the matrix.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1,2,0],[0,0,3],[4,0,5]])
 |      >>> A.nonzero()
 |      (array([0, 0, 1, 2, 2]), array([0, 1, 2, 0, 2]))
 |  
 |  tocsc(self, copy=False)
 |      Convert this matrix to Compressed Sparse Column format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant csc_matrix.
 |  
 |  tocsr(self, copy=False)
 |      Convert this matrix to Compressed Sparse Row format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant csr_matrix.
 |  
 |  transpose(self, axes=None, copy=False)
 |      Reverses the dimensions of the sparse matrix.
 |      
 |      Parameters
 |      ----------
 |      axes : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value.
 |      copy : bool, optional
 |          Indicates whether or not attributes of `self` should be
 |          copied whenever possible. The degree to which attributes
 |          are copied varies depending on the type of sparse matrix
 |          being used.
 |      
 |      Returns
 |      -------
 |      p : `self` with the dimensions reversed.
 |      
 |      See Also
 |      --------
 |      np.matrix.transpose : NumPy's implementation of 'transpose'
 |                            for matrices
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  format = 'csc'
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.compressed._cs_matrix:
 |  
 |  __eq__(self, other)
 |      Return self==value.
 |  
 |  __ge__(self, other)
 |      Return self>=value.
 |  
 |  __gt__(self, other)
 |      Return self>value.
 |  
 |  __init__(self, arg1, shape=None, dtype=None, copy=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __le__(self, other)
 |      Return self<=value.
 |  
 |  __lt__(self, other)
 |      Return self<value.
 |  
 |  __ne__(self, other)
 |      Return self!=value.
 |  
 |  __setitem__(self, index, x)
 |  
 |  check_format(self, full_check=True)
 |      check whether the matrix format is valid
 |      
 |      Parameters
 |      ----------
 |      full_check : bool, optional
 |          If `True`, rigorous check, O(N) operations. Otherwise
 |          basic check, O(1) operations (default True).
 |  
 |  diagonal(self, k=0)
 |      Returns the k-th diagonal of the matrix.
 |      
 |      Parameters
 |      ----------
 |      k : int, optional
 |          Which diagonal to set, corresponding to elements a[i, i+k].
 |          Default: 0 (the main diagonal).
 |      
 |          .. versionadded:: 1.0
 |      
 |      See also
 |      --------
 |      numpy.diagonal : Equivalent numpy function.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> A.diagonal()
 |      array([1, 0, 5])
 |      >>> A.diagonal(k=1)
 |      array([2, 3])
 |  
 |  eliminate_zeros(self)
 |      Remove zero entries from the matrix
 |      
 |      This is an *in place* operation
 |  
 |  getnnz(self, axis=None)
 |      Number of stored values, including explicit zeros.
 |      
 |      Parameters
 |      ----------
 |      axis : None, 0, or 1
 |          Select between the number of values across the whole matrix, in
 |          each column, or in each row.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  maximum(self, other)
 |      Element-wise maximum between this and another matrix.
 |  
 |  minimum(self, other)
 |      Element-wise minimum between this and another matrix.
 |  
 |  multiply(self, other)
 |      Point-wise multiplication by another matrix, vector, or
 |      scalar.
 |  
 |  prune(self)
 |      Remove empty space after all non-zero elements.
 |  
 |  resize(self, *shape)
 |      Resize the matrix in-place to dimensions given by ``shape``
 |      
 |      Any elements that lie within the new shape will remain at the same
 |      indices, while non-zero elements lying outside the new shape are
 |      removed.
 |      
 |      Parameters
 |      ----------
 |      shape : (int, int)
 |          number of rows and columns in the new matrix
 |      
 |      Notes
 |      -----
 |      The semantics are not identical to `numpy.ndarray.resize` or
 |      `numpy.resize`.  Here, the same data will be maintained at each index
 |      before and after reshape, if that index is within the new bounds.  In
 |      numpy, resizing maintains contiguity of the array, moving elements
 |      around in the logical matrix but not within a flattened representation.
 |      
 |      We give no guarantees about whether the underlying data attributes
 |      (arrays, etc.) will be modified in place or replaced with new objects.
 |  
 |  sort_indices(self)
 |      Sort the indices of this matrix *in place*
 |  
 |  sorted_indices(self)
 |      Return a copy of this matrix with sorted indices
 |  
 |  sum(self, axis=None, dtype=None, out=None)
 |      Sum the matrix elements over a given axis.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the sum of all the matrix elements, returning a scalar
 |          (i.e. `axis` = `None`).
 |      dtype : dtype, optional
 |          The type of the returned matrix and of the accumulator in which
 |          the elements are summed.  The dtype of `a` is used by default
 |          unless `a` has an integer dtype of less precision than the default
 |          platform integer.  In that case, if `a` is signed then the platform
 |          integer is used while if `a` is unsigned then an unsigned integer
 |          of the same precision as the platform integer is used.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      sum_along_axis : np.matrix
 |          A matrix with the same shape as `self`, with the specified
 |          axis removed.
 |      
 |      See Also
 |      --------
 |      np.matrix.sum : NumPy's implementation of 'sum' for matrices
 |  
 |  sum_duplicates(self)
 |      Eliminate duplicate matrix entries by adding them together
 |      
 |      The is an *in place* operation
 |  
 |  toarray(self, order=None, out=None)
 |      Return a dense ndarray representation of this matrix.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F'}, optional
 |          Whether to store multi-dimensional data in C (row-major)
 |          or Fortran (column-major) order in memory. The default
 |          is 'None', indicating the NumPy default of C-ordered.
 |          Cannot be specified in conjunction with the `out`
 |          argument.
 |      
 |      out : ndarray, 2-dimensional, optional
 |          If specified, uses this array as the output buffer
 |          instead of allocating a new array to return. The provided
 |          array must have the same shape and dtype as the sparse
 |          matrix on which you are calling the method. For most
 |          sparse types, `out` is required to be memory contiguous
 |          (either C or Fortran ordered).
 |      
 |      Returns
 |      -------
 |      arr : ndarray, 2-dimensional
 |          An array with the same shape and containing the same
 |          data represented by the sparse matrix, with the requested
 |          memory order. If `out` was passed, the same object is
 |          returned after being modified in-place to contain the
 |          appropriate values.
 |  
 |  tocoo(self, copy=True)
 |      Convert this matrix to COOrdinate format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant coo_matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.compressed._cs_matrix:
 |  
 |  has_canonical_format
 |      Determine whether the matrix has sorted indices and no duplicates
 |      
 |      Returns
 |          - True: if the above applies
 |          - False: otherwise
 |      
 |      has_canonical_format implies has_sorted_indices, so if the latter flag
 |      is False, so will the former be; if the former is found True, the
 |      latter flag is also set.
 |  
 |  has_sorted_indices
 |      Determine whether the matrix has sorted indices
 |      
 |      Returns
 |          - True: if the indices of the matrix are in sorted order
 |          - False: otherwise
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.sparse.compressed._cs_matrix:
 |  
 |  __hash__ = None
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._data_matrix:
 |  
 |  __abs__(self)
 |  
 |  __imul__(self, other)
 |  
 |  __itruediv__(self, other)
 |  
 |  __neg__(self)
 |  
 |  arcsin(self)
 |      Element-wise arcsin.
 |      
 |      See numpy.arcsin for more information.
 |  
 |  arcsinh(self)
 |      Element-wise arcsinh.
 |      
 |      See numpy.arcsinh for more information.
 |  
 |  arctan(self)
 |      Element-wise arctan.
 |      
 |      See numpy.arctan for more information.
 |  
 |  arctanh(self)
 |      Element-wise arctanh.
 |      
 |      See numpy.arctanh for more information.
 |  
 |  astype(self, dtype, casting='unsafe', copy=True)
 |      Cast the matrix elements to a specified type.
 |      
 |      Parameters
 |      ----------
 |      dtype : string or numpy dtype
 |          Typecode or data-type to which to cast the data.
 |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
 |          Controls what kind of data casting may occur.
 |          Defaults to 'unsafe' for backwards compatibility.
 |          'no' means the data types should not be cast at all.
 |          'equiv' means only byte-order changes are allowed.
 |          'safe' means only casts which can preserve values are allowed.
 |          'same_kind' means only safe casts or casts within a kind,
 |          like float64 to float32, are allowed.
 |          'unsafe' means any data conversions may be done.
 |      copy : bool, optional
 |          If `copy` is `False`, the result might share some memory with this
 |          matrix. If `copy` is `True`, it is guaranteed that the result and
 |          this matrix do not share any memory.
 |  
 |  ceil(self)
 |      Element-wise ceil.
 |      
 |      See numpy.ceil for more information.
 |  
 |  conj(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  copy(self)
 |      Returns a copy of this matrix.
 |      
 |      No data/indices will be shared between the returned value and current
 |      matrix.
 |  
 |  count_nonzero(self)
 |      Number of non-zero entries, equivalent to
 |      
 |      np.count_nonzero(a.toarray())
 |      
 |      Unlike getnnz() and the nnz property, which return the number of stored
 |      entries (the length of the data attribute), this method counts the
 |      actual number of non-zero entries in data.
 |  
 |  deg2rad(self)
 |      Element-wise deg2rad.
 |      
 |      See numpy.deg2rad for more information.
 |  
 |  expm1(self)
 |      Element-wise expm1.
 |      
 |      See numpy.expm1 for more information.
 |  
 |  floor(self)
 |      Element-wise floor.
 |      
 |      See numpy.floor for more information.
 |  
 |  log1p(self)
 |      Element-wise log1p.
 |      
 |      See numpy.log1p for more information.
 |  
 |  power(self, n, dtype=None)
 |      This function performs element-wise power.
 |      
 |      Parameters
 |      ----------
 |      n : n is a scalar
 |      
 |      dtype : If dtype is not specified, the current dtype will be preserved.
 |  
 |  rad2deg(self)
 |      Element-wise rad2deg.
 |      
 |      See numpy.rad2deg for more information.
 |  
 |  rint(self)
 |      Element-wise rint.
 |      
 |      See numpy.rint for more information.
 |  
 |  sign(self)
 |      Element-wise sign.
 |      
 |      See numpy.sign for more information.
 |  
 |  sin(self)
 |      Element-wise sin.
 |      
 |      See numpy.sin for more information.
 |  
 |  sinh(self)
 |      Element-wise sinh.
 |      
 |      See numpy.sinh for more information.
 |  
 |  sqrt(self)
 |      Element-wise sqrt.
 |      
 |      See numpy.sqrt for more information.
 |  
 |  tan(self)
 |      Element-wise tan.
 |      
 |      See numpy.tan for more information.
 |  
 |  tanh(self)
 |      Element-wise tanh.
 |      
 |      See numpy.tanh for more information.
 |  
 |  trunc(self)
 |      Element-wise trunc.
 |      
 |      See numpy.trunc for more information.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.data._data_matrix:
 |  
 |  dtype
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.base.spmatrix:
 |  
 |  __add__(self, other)
 |  
 |  __bool__(self)
 |  
 |  __div__(self, other)
 |  
 |  __getattr__(self, attr)
 |  
 |  __iadd__(self, other)
 |  
 |  __idiv__(self, other)
 |  
 |  __isub__(self, other)
 |  
 |  __len__(self)
 |      # What should len(sparse) return? For consistency with dense matrices,
 |      # perhaps it should be the number of rows?  But for some uses the number of
 |      # non-zeros is more important.  For now, raise an exception!
 |  
 |  __matmul__(self, other)
 |  
 |  __mul__(self, other)
 |      interpret other and call one of the following
 |      
 |      self._mul_scalar()
 |      self._mul_vector()
 |      self._mul_multivector()
 |      self._mul_sparse_matrix()
 |  
 |  __nonzero__ = __bool__(self)
 |  
 |  __pow__(self, other)
 |  
 |  __radd__(self, other)
 |  
 |  __rdiv__(self, other)
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __rmatmul__(self, other)
 |  
 |  __rmul__(self, other)
 |  
 |  __rsub__(self, other)
 |  
 |  __rtruediv__(self, other)
 |  
 |  __str__(self)
 |      Return str(self).
 |  
 |  __sub__(self, other)
 |  
 |  __truediv__(self, other)
 |  
 |  asformat(self, format, copy=False)
 |      Return this matrix in the passed sparse format.
 |      
 |      Parameters
 |      ----------
 |      format : {str, None}
 |          The desired sparse matrix format (""csr"", ""csc"", ""lil"", ""dok"", ...)
 |          or None for no conversion.
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : This matrix in the passed sparse format.
 |  
 |  asfptype(self)
 |      Upcast matrix to a floating point format (if necessary)
 |  
 |  conjugate(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  dot(self, other)
 |      Ordinary dot product
 |      
 |      Examples
 |      --------
 |      >>> import numpy as np
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> v = np.array([1, 0, -1])
 |      >>> A.dot(v)
 |      array([ 1, -3, -1], dtype=int64)
 |  
 |  getH(self)
 |      Return the Hermitian transpose of this matrix.
 |      
 |      See Also
 |      --------
 |      np.matrix.getH : NumPy's implementation of `getH` for matrices
 |  
 |  get_shape(self)
 |      Get shape of a matrix.
 |  
 |  getformat(self)
 |      Format of a matrix representation as a string.
 |  
 |  getmaxprint(self)
 |      Maximum number of elements to display when printed.
 |  
 |  mean(self, axis=None, dtype=None, out=None)
 |      Compute the arithmetic mean along the specified axis.
 |      
 |      Returns the average of the matrix elements. The average is taken
 |      over all elements in the matrix by default, otherwise over the
 |      specified axis. `float64` intermediate and return values are used
 |      for integer inputs.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the mean is computed. The default is to compute
 |          the mean of all elements in the matrix (i.e. `axis` = `None`).
 |      dtype : data-type, optional
 |          Type to use in computing the mean. For integer inputs, the default
 |          is `float64`; for floating point inputs, it is the same as the
 |          input dtype.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      m : np.matrix
 |      
 |      See Also
 |      --------
 |      np.matrix.mean : NumPy's implementation of 'mean' for matrices
 |  
 |  reshape(self, *args, **kwargs)
 |      reshape(self, shape, order='C', copy=False)
 |      
 |      Gives a new shape to a sparse matrix without changing its data.
 |      
 |      Parameters
 |      ----------
 |      shape : length-2 tuple of ints
 |          The new shape should be compatible with the original shape.
 |      order : {'C', 'F'}, optional
 |          Read the elements using this index order. 'C' means to read and
 |          write the elements using C-like index order; e.g. read entire first
 |          row, then second row, etc. 'F' means to read and write the elements
 |          using Fortran-like index order; e.g. read entire first column, then
 |          second column, etc.
 |      copy : bool, optional
 |          Indicates whether or not attributes of self should be copied
 |          whenever possible. The degree to which attributes are copied varies
 |          depending on the type of sparse matrix being used.
 |      
 |      Returns
 |      -------
 |      reshaped_matrix : sparse matrix
 |          A sparse matrix with the given `shape`, not necessarily of the same
 |          format as the current object.
 |      
 |      See Also
 |      --------
 |      np.matrix.reshape : NumPy's implementation of 'reshape' for matrices
 |  
 |  set_shape(self, shape)
 |      See `reshape`.
 |  
 |  setdiag(self, values, k=0)
 |      Set diagonal or off-diagonal elements of the array.
 |      
 |      Parameters
 |      ----------
 |      values : array_like
 |          New values of the diagonal elements.
 |      
 |          Values may have any length.  If the diagonal is longer than values,
 |          then the remaining diagonal entries will not be set.  If values if
 |          longer than the diagonal, then the remaining values are ignored.
 |      
 |          If a scalar value is given, all of the diagonal is set to it.
 |      
 |      k : int, optional
 |          Which off-diagonal to set, corresponding to elements a[i,i+k].
 |          Default: 0 (the main diagonal).
 |  
 |  tobsr(self, blocksize=None, copy=False)
 |      Convert this matrix to Block Sparse Row format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant bsr_matrix.
 |      
 |      When blocksize=(R, C) is provided, it will be used for construction of
 |      the bsr_matrix.
 |  
 |  todense(self, order=None, out=None)
 |      Return a dense matrix representation of this matrix.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F'}, optional
 |          Whether to store multi-dimensional data in C (row-major)
 |          or Fortran (column-major) order in memory. The default
 |          is 'None', indicating the NumPy default of C-ordered.
 |          Cannot be specified in conjunction with the `out`
 |          argument.
 |      
 |      out : ndarray, 2-dimensional, optional
 |          If specified, uses this array (or `numpy.matrix`) as the
 |          output buffer instead of allocating a new array to
 |          return. The provided array must have the same shape and
 |          dtype as the sparse matrix on which you are calling the
 |          method.
 |      
 |      Returns
 |      -------
 |      arr : numpy.matrix, 2-dimensional
 |          A NumPy matrix object with the same shape and containing
 |          the same data represented by the sparse matrix, with the
 |          requested memory order. If `out` was passed and was an
 |          array (rather than a `numpy.matrix`), it will be filled
 |          with the appropriate values and returned wrapped in a
 |          `numpy.matrix` object that shares the same memory.
 |  
 |  todia(self, copy=False)
 |      Convert this matrix to sparse DIAgonal format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dia_matrix.
 |  
 |  todok(self, copy=False)
 |      Convert this matrix to Dictionary Of Keys format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dok_matrix.
 |  
 |  tolil(self, copy=False)
 |      Convert this matrix to LInked List format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant lil_matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.base.spmatrix:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  nnz
 |      Number of stored values, including explicit zeros.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  shape
 |      Get shape of a matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.sparse.base.spmatrix:
 |  
 |  __array_priority__ = 10.1
 |  
 |  ndim = 2
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._minmax_mixin:
 |  
 |  argmax(self, axis=None, out=None)
 |      Return indices of maximum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several maximum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmax is computed. If None (default), index
 |          of the maximum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      ind : np.matrix or int
 |          Indices of maximum elements. If matrix, its size along `axis` is 1.
 |  
 |  argmin(self, axis=None, out=None)
 |      Return indices of minimum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several minimum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmin is computed. If None (default), index
 |          of the minimum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |       ind : np.matrix or int
 |          Indices of minimum elements. If matrix, its size along `axis` is 1.
 |  
 |  max(self, axis=None, out=None)
 |      Return the maximum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the maximum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amax : coo_matrix or scalar
 |          Maximum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      min : The minimum value of a sparse matrix along a given axis.
 |      np.matrix.max : NumPy's implementation of 'max' for matrices
 |  
 |  min(self, axis=None, out=None)
 |      Return the minimum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the minimum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amin : coo_matrix or scalar
 |          Minimum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      max : The maximum value of a sparse matrix along a given axis.
 |      np.matrix.min : NumPy's implementation of 'min' for matrices
",class,"('self', 'arg1', 'shape', 'dtype', 'copy')","(nan, nan, None, None, False)","(nan, nan, 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, arg1, shape=None, dtype=None, copy=False)',)"
scipy,1.1.0,scipy.integrate._ivp.bdf.eye,integrate._ivp.bdf,eye,"Python Library Documentation: function eye in module scipy.sparse.construct

eye(m, n=None, k=0, dtype=<class 'float'>, format=None)
    Sparse matrix with ones on diagonal
    
    Returns a sparse (m x n) matrix where the k-th diagonal
    is all ones and everything else is zeros.
    
    Parameters
    ----------
    m : int
        Number of rows in the matrix.
    n : int, optional
        Number of columns. Default: `m`.
    k : int, optional
        Diagonal to place ones on. Default: 0 (main diagonal).
    dtype : dtype, optional
        Data type of the matrix.
    format : str, optional
        Sparse format of the result, e.g. format=""csr"", etc.
    
    Examples
    --------
    >>> from scipy import sparse
    >>> sparse.eye(3).toarray()
    array([[ 1.,  0.,  0.],
           [ 0.,  1.,  0.],
           [ 0.,  0.,  1.]])
    >>> sparse.eye(3, dtype=np.int8)
    <3x3 sparse matrix of type '<class 'numpy.int8'>'
        with 3 stored elements (1 diagonals) in DIAgonal format>
",function,"(""(m, n=None, k=0, dtype=<class 'float'>, format=None)"",)",scipy,1.1.0,scipy.integrate._ivp.bdf.eye,integrate._ivp.bdf,eye,"Python Library Documentation: function eye in module scipy.sparse.construct

eye(m, n=None, k=0, dtype=<class 'float'>, format=None)
    Sparse matrix with ones on diagonal
    
    Returns a sparse (m x n) matrix where the k-th diagonal
    is all ones and everything else is zeros.
    
    Parameters
    ----------
    m : int
        Number of rows in the matrix.
    n : int, optional
        Number of columns. Default: `m`.
    k : int, optional
        Diagonal to place ones on. Default: 0 (main diagonal).
    dtype : dtype, optional
        Data type of the matrix.
    format : str, optional
        Sparse format of the result, e.g. format=""csr"", etc.
    
    Examples
    --------
    >>> from scipy import sparse
    >>> sparse.eye(3).toarray()
    array([[ 1.,  0.,  0.],
           [ 0.,  1.,  0.],
           [ 0.,  0.,  1.]])
    >>> sparse.eye(3, dtype=np.int8)
    <3x3 sparse matrix of type '<class 'numpy.int8'>'
        with 3 stored elements (1 diagonals) in DIAgonal format>
",function,"('m', 'n', 'k', 'dtype', 'format')","(nan, None, 0, <class 'float'>, None)","(nan, 'NoneType', 'int', 'type', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(m, n=None, k=0, dtype=<class 'float'>, format=None)"",)"
scipy,1.1.0,scipy.integrate._ivp.bdf.group_columns,integrate._ivp.bdf,group_columns,"Python Library Documentation: function group_columns in module scipy.optimize._numdiff

group_columns(A, order=0)
    Group columns of a 2-d matrix for sparse finite differencing [1]_.
    
    Two columns are in the same group if in each row at least one of them
    has zero. A greedy sequential algorithm is used to construct groups.
    
    Parameters
    ----------
    A : array_like or sparse matrix, shape (m, n)
        Matrix of which to group columns.
    order : int, iterable of int with shape (n,) or None
        Permutation array which defines the order of columns enumeration.
        If int or None, a random permutation is used with `order` used as
        a random seed. Default is 0, that is use a random permutation but
        guarantee repeatability.
    
    Returns
    -------
    groups : ndarray of int, shape (n,)
        Contains values from 0 to n_groups-1, where n_groups is the number
        of found groups. Each value ``groups[i]`` is an index of a group to
        which i-th column assigned. The procedure was helpful only if
        n_groups is significantly less than n.
    
    References
    ----------
    .. [1] A. Curtis, M. J. D. Powell, and J. Reid, ""On the estimation of
           sparse Jacobian matrices"", Journal of the Institute of Mathematics
           and its Applications, 13 (1974), pp. 117-120.
",function,"('(A, order=0)',)",scipy,1.1.0,scipy.integrate._ivp.bdf.group_columns,integrate._ivp.bdf,group_columns,"Python Library Documentation: function group_columns in module scipy.optimize._numdiff

group_columns(A, order=0)
    Group columns of a 2-d matrix for sparse finite differencing [1]_.
    
    Two columns are in the same group if in each row at least one of them
    has zero. A greedy sequential algorithm is used to construct groups.
    
    Parameters
    ----------
    A : array_like or sparse matrix, shape (m, n)
        Matrix of which to group columns.
    order : int, iterable of int with shape (n,) or None
        Permutation array which defines the order of columns enumeration.
        If int or None, a random permutation is used with `order` used as
        a random seed. Default is 0, that is use a random permutation but
        guarantee repeatability.
    
    Returns
    -------
    groups : ndarray of int, shape (n,)
        Contains values from 0 to n_groups-1, where n_groups is the number
        of found groups. Each value ``groups[i]`` is an index of a group to
        which i-th column assigned. The procedure was helpful only if
        n_groups is significantly less than n.
    
    References
    ----------
    .. [1] A. Curtis, M. J. D. Powell, and J. Reid, ""On the estimation of
           sparse Jacobian matrices"", Journal of the Institute of Mathematics
           and its Applications, 13 (1974), pp. 117-120.
",function,"('A', 'order')","(nan, 0)","(nan, 'int')","('arg_info', 'arg_info')","('(A, order=0)',)"
scipy,1.1.0,scipy.integrate._ivp.bdf.issparse,integrate._ivp.bdf,isspmatrix,"Python Library Documentation: function isspmatrix in module scipy.sparse.base

isspmatrix(x)
    Is x of a sparse matrix type?
    
    Parameters
    ----------
    x
        object to check for being a sparse matrix
    
    Returns
    -------
    bool
        True if x is a sparse matrix, False otherwise
    
    Notes
    -----
    issparse and isspmatrix are aliases for the same function.
    
    Examples
    --------
    >>> from scipy.sparse import csr_matrix, isspmatrix
    >>> isspmatrix(csr_matrix([[5]]))
    True
    
    >>> from scipy.sparse import isspmatrix
    >>> isspmatrix(5)
    False
",function,"('(x)',)",scipy,1.1.0,scipy.integrate._ivp.bdf.issparse,integrate._ivp.bdf,isspmatrix,"Python Library Documentation: function isspmatrix in module scipy.sparse.base

isspmatrix(x)
    Is x of a sparse matrix type?
    
    Parameters
    ----------
    x
        object to check for being a sparse matrix
    
    Returns
    -------
    bool
        True if x is a sparse matrix, False otherwise
    
    Notes
    -----
    issparse and isspmatrix are aliases for the same function.
    
    Examples
    --------
    >>> from scipy.sparse import csr_matrix, isspmatrix
    >>> isspmatrix(csr_matrix([[5]]))
    True
    
    >>> from scipy.sparse import isspmatrix
    >>> isspmatrix(5)
    False
",function,"('x',)","(nan,)","(nan,)","('arg_info',)","('(x)',)"
scipy,1.1.0,scipy.integrate._ivp.bdf.lu_factor,integrate._ivp.bdf,lu_factor,"Python Library Documentation: function lu_factor in module scipy.linalg.decomp_lu

lu_factor(a, overwrite_a=False, check_finite=True)
    Compute pivoted LU decomposition of a matrix.
    
    The decomposition is::
    
        A = P L U
    
    where P is a permutation matrix, L lower triangular with unit
    diagonal elements, and U upper triangular.
    
    Parameters
    ----------
    a : (M, M) array_like
        Matrix to decompose
    overwrite_a : bool, optional
        Whether to overwrite data in A (may increase performance)
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    lu : (N, N) ndarray
        Matrix containing U in its upper triangle, and L in its lower triangle.
        The unit diagonal elements of L are not stored.
    piv : (N,) ndarray
        Pivot indices representing the permutation matrix P:
        row i of matrix was interchanged with row piv[i].
    
    See also
    --------
    lu_solve : solve an equation system using the LU factorization of a matrix
    
    Notes
    -----
    This is a wrapper to the ``*GETRF`` routines from LAPACK.
    
    Examples
    --------
    >>> from scipy.linalg import lu_factor
    >>> from numpy import tril, triu, allclose, zeros, eye
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> lu, piv = lu_factor(A)
    >>> piv
    array([2, 2, 3, 3], dtype=int32)
    
    Convert LAPACK's ``piv`` array to NumPy index and test the permutation 
    
    >>> piv_py = [2, 0, 3, 1]
    >>> L, U = np.tril(lu, k=-1) + np.eye(4), np.triu(lu)
    >>> np.allclose(A[piv_py] - L @ U, np.zeros((4, 4)))
    True
",function,"('(a, overwrite_a=False, check_finite=True)',)",scipy,1.1.0,scipy.integrate._ivp.bdf.lu_factor,integrate._ivp.bdf,lu_factor,"Python Library Documentation: function lu_factor in module scipy.linalg.decomp_lu

lu_factor(a, overwrite_a=False, check_finite=True)
    Compute pivoted LU decomposition of a matrix.
    
    The decomposition is::
    
        A = P L U
    
    where P is a permutation matrix, L lower triangular with unit
    diagonal elements, and U upper triangular.
    
    Parameters
    ----------
    a : (M, M) array_like
        Matrix to decompose
    overwrite_a : bool, optional
        Whether to overwrite data in A (may increase performance)
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    lu : (N, N) ndarray
        Matrix containing U in its upper triangle, and L in its lower triangle.
        The unit diagonal elements of L are not stored.
    piv : (N,) ndarray
        Pivot indices representing the permutation matrix P:
        row i of matrix was interchanged with row piv[i].
    
    See also
    --------
    lu_solve : solve an equation system using the LU factorization of a matrix
    
    Notes
    -----
    This is a wrapper to the ``*GETRF`` routines from LAPACK.
    
    Examples
    --------
    >>> from scipy.linalg import lu_factor
    >>> from numpy import tril, triu, allclose, zeros, eye
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> lu, piv = lu_factor(A)
    >>> piv
    array([2, 2, 3, 3], dtype=int32)
    
    Convert LAPACK's ``piv`` array to NumPy index and test the permutation 
    
    >>> piv_py = [2, 0, 3, 1]
    >>> L, U = np.tril(lu, k=-1) + np.eye(4), np.triu(lu)
    >>> np.allclose(A[piv_py] - L @ U, np.zeros((4, 4)))
    True
",function,"('a', 'overwrite_a', 'check_finite')","(nan, False, True)","(nan, 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info')","('(a, overwrite_a=False, check_finite=True)',)"
scipy,1.1.0,scipy.integrate._ivp.bdf.lu_solve,integrate._ivp.bdf,lu_solve,"Python Library Documentation: function lu_solve in module scipy.linalg.decomp_lu

lu_solve(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True)
    Solve an equation system, a x = b, given the LU factorization of a
    
    Parameters
    ----------
    (lu, piv)
        Factorization of the coefficient matrix a, as given by lu_factor
    b : array
        Right-hand side
    trans : {0, 1, 2}, optional
        Type of system to solve:
    
        =====  =========
        trans  system
        =====  =========
        0      a x   = b
        1      a^T x = b
        2      a^H x = b
        =====  =========
    overwrite_b : bool, optional
        Whether to overwrite data in b (may increase performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : array
        Solution to the system
    
    See also
    --------
    lu_factor : LU factorize a matrix
    
    Examples
    --------
    >>> from scipy.linalg import lu_factor, lu_solve
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> b = np.array([1, 1, 1, 1])
    >>> lu, piv = lu_factor(A)
    >>> x = lu_solve((lu, piv), b)
    >>> np.allclose(A @ x - b, np.zeros((4,)))
    True
",function,"('(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True)',)",scipy,1.1.0,scipy.integrate._ivp.bdf.lu_solve,integrate._ivp.bdf,lu_solve,"Python Library Documentation: function lu_solve in module scipy.linalg.decomp_lu

lu_solve(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True)
    Solve an equation system, a x = b, given the LU factorization of a
    
    Parameters
    ----------
    (lu, piv)
        Factorization of the coefficient matrix a, as given by lu_factor
    b : array
        Right-hand side
    trans : {0, 1, 2}, optional
        Type of system to solve:
    
        =====  =========
        trans  system
        =====  =========
        0      a x   = b
        1      a^T x = b
        2      a^H x = b
        =====  =========
    overwrite_b : bool, optional
        Whether to overwrite data in b (may increase performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : array
        Solution to the system
    
    See also
    --------
    lu_factor : LU factorize a matrix
    
    Examples
    --------
    >>> from scipy.linalg import lu_factor, lu_solve
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> b = np.array([1, 1, 1, 1])
    >>> lu, piv = lu_factor(A)
    >>> x = lu_solve((lu, piv), b)
    >>> np.allclose(A @ x - b, np.zeros((4,)))
    True
",function,"('lu_and_piv', 'b', 'trans', 'overwrite_b', 'check_finite')","(nan, nan, 0, False, True)","(nan, nan, 'int', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True)',)"
scipy,1.1.0,scipy.integrate._ivp.bdf.norm,integrate._ivp.bdf,norm,"Python Library Documentation: function norm in module scipy.integrate._ivp.common

norm(x)
    Compute RMS norm.
",function,"('(x)',)",scipy,1.1.0,scipy.integrate._ivp.bdf.norm,integrate._ivp.bdf,norm,"Python Library Documentation: function norm in module scipy.integrate._ivp.common

norm(x)
    Compute RMS norm.
",function,"('x',)","(nan,)","(nan,)","('arg_info',)","('(x)',)"
scipy,1.1.0,scipy.integrate._ivp.bdf.num_jac,integrate._ivp.bdf,num_jac,"Python Library Documentation: function num_jac in module scipy.integrate._ivp.common

num_jac(fun, t, y, f, threshold, factor, sparsity=None)
    Finite differences Jacobian approximation tailored for ODE solvers.
    
    This function computes finite difference approximation to the Jacobian
    matrix of `fun` with respect to `y` using forward differences.
    The Jacobian matrix has shape (n, n) and its element (i, j) is equal to
    ``d f_i / d y_j``.
    
    A special feature of this function is the ability to correct the step
    size from iteration to iteration. The main idea is to keep the finite
    difference significantly separated from its round-off error which
    approximately equals ``EPS * np.abs(f)``. It reduces a possibility of a
    huge error and assures that the estimated derivative are reasonably close
    to the true values (i.e. the finite difference approximation is at least
    qualitatively reflects the structure of the true Jacobian).
    
    Parameters
    ----------
    fun : callable
        Right-hand side of the system implemented in a vectorized fashion.
    t : float
        Current time.
    y : ndarray, shape (n,)
        Current state.
    f : ndarray, shape (n,)
        Value of the right hand side at (t, y).
    threshold : float
        Threshold for `y` value used for computing the step size as
        ``factor * np.maximum(np.abs(y), threshold)``. Typically the value of
        absolute tolerance (atol) for a solver should be passed as `threshold`.
    factor : ndarray with shape (n,) or None
        Factor to use for computing the step size. Pass None for the very
        evaluation, then use the value returned from this function.
    sparsity : tuple (structure, groups) or None
        Sparsity structure of the Jacobian, `structure` must be csc_matrix.
    
    Returns
    -------
    J : ndarray or csc_matrix, shape (n, n)
        Jacobian matrix.
    factor : ndarray, shape (n,)
        Suggested `factor` for the next evaluation.
",function,"('(fun, t, y, f, threshold, factor, sparsity=None)',)",scipy,1.1.0,scipy.integrate._ivp.bdf.num_jac,integrate._ivp.bdf,num_jac,"Python Library Documentation: function num_jac in module scipy.integrate._ivp.common

num_jac(fun, t, y, f, threshold, factor, sparsity=None)
    Finite differences Jacobian approximation tailored for ODE solvers.
    
    This function computes finite difference approximation to the Jacobian
    matrix of `fun` with respect to `y` using forward differences.
    The Jacobian matrix has shape (n, n) and its element (i, j) is equal to
    ``d f_i / d y_j``.
    
    A special feature of this function is the ability to correct the step
    size from iteration to iteration. The main idea is to keep the finite
    difference significantly separated from its round-off error which
    approximately equals ``EPS * np.abs(f)``. It reduces a possibility of a
    huge error and assures that the estimated derivative are reasonably close
    to the true values (i.e. the finite difference approximation is at least
    qualitatively reflects the structure of the true Jacobian).
    
    Parameters
    ----------
    fun : callable
        Right-hand side of the system implemented in a vectorized fashion.
    t : float
        Current time.
    y : ndarray, shape (n,)
        Current state.
    f : ndarray, shape (n,)
        Value of the right hand side at (t, y).
    threshold : float
        Threshold for `y` value used for computing the step size as
        ``factor * np.maximum(np.abs(y), threshold)``. Typically the value of
        absolute tolerance (atol) for a solver should be passed as `threshold`.
    factor : ndarray with shape (n,) or None
        Factor to use for computing the step size. Pass None for the very
        evaluation, then use the value returned from this function.
    sparsity : tuple (structure, groups) or None
        Sparsity structure of the Jacobian, `structure` must be csc_matrix.
    
    Returns
    -------
    J : ndarray or csc_matrix, shape (n, n)
        Jacobian matrix.
    factor : ndarray, shape (n,)
        Suggested `factor` for the next evaluation.
",function,"('fun', 't', 'y', 'f', 'threshold', 'factor', 'sparsity')","(nan, nan, nan, nan, nan, nan, None)","(nan, nan, nan, nan, nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(fun, t, y, f, threshold, factor, sparsity=None)',)"
scipy,1.1.0,scipy.integrate._ivp.bdf.select_initial_step,integrate._ivp.bdf,select_initial_step,"Python Library Documentation: function select_initial_step in module scipy.integrate._ivp.common

select_initial_step(fun, t0, y0, f0, direction, order, rtol, atol)
    Empirically select a good initial step.
    
    The algorithm is described in [1]_.
    
    Parameters
    ----------
    fun : callable
        Right-hand side of the system.
    t0 : float
        Initial value of the independent variable.
    y0 : ndarray, shape (n,)
        Initial value of the dependent variable.
    f0 : ndarray, shape (n,)
        Initial value of the derivative, i. e. ``fun(t0, y0)``.
    direction : float
        Integration direction.
    order : float
        Method order.
    rtol : float
        Desired relative tolerance.
    atol : float
        Desired absolute tolerance.
    
    Returns
    -------
    h_abs : float
        Absolute value of the suggested initial step.
    
    References
    ----------
    .. [1] E. Hairer, S. P. Norsett G. Wanner, ""Solving Ordinary Differential
           Equations I: Nonstiff Problems"", Sec. II.4.
",function,"('(fun, t0, y0, f0, direction, order, rtol, atol)',)",scipy,1.1.0,scipy.integrate._ivp.bdf.select_initial_step,integrate._ivp.bdf,select_initial_step,"Python Library Documentation: function select_initial_step in module scipy.integrate._ivp.common

select_initial_step(fun, t0, y0, f0, direction, order, rtol, atol)
    Empirically select a good initial step.
    
    The algorithm is described in [1]_.
    
    Parameters
    ----------
    fun : callable
        Right-hand side of the system.
    t0 : float
        Initial value of the independent variable.
    y0 : ndarray, shape (n,)
        Initial value of the dependent variable.
    f0 : ndarray, shape (n,)
        Initial value of the derivative, i. e. ``fun(t0, y0)``.
    direction : float
        Integration direction.
    order : float
        Method order.
    rtol : float
        Desired relative tolerance.
    atol : float
        Desired absolute tolerance.
    
    Returns
    -------
    h_abs : float
        Absolute value of the suggested initial step.
    
    References
    ----------
    .. [1] E. Hairer, S. P. Norsett G. Wanner, ""Solving Ordinary Differential
           Equations I: Nonstiff Problems"", Sec. II.4.
",function,"('fun', 't0', 'y0', 'f0', 'direction', 'order', 'rtol', 'atol')","(nan, nan, nan, nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(fun, t0, y0, f0, direction, order, rtol, atol)',)"
scipy,1.1.0,scipy.integrate._ivp.bdf.solve_bdf_system,integrate._ivp.bdf,solve_bdf_system,"Python Library Documentation: function solve_bdf_system in module scipy.integrate._ivp.bdf

solve_bdf_system(fun, t_new, y_predict, c, psi, LU, solve_lu, scale, tol)
    Solve the algebraic system resulting from BDF method.
",function,"('(fun, t_new, y_predict, c, psi, LU, solve_lu, scale, tol)',)",scipy,1.1.0,scipy.integrate._ivp.bdf.solve_bdf_system,integrate._ivp.bdf,solve_bdf_system,"Python Library Documentation: function solve_bdf_system in module scipy.integrate._ivp.bdf

solve_bdf_system(fun, t_new, y_predict, c, psi, LU, solve_lu, scale, tol)
    Solve the algebraic system resulting from BDF method.
",function,"('fun', 't_new', 'y_predict', 'c', 'psi', 'LU', 'solve_lu', 'scale', 'tol')","(nan, nan, nan, nan, nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(fun, t_new, y_predict, c, psi, LU, solve_lu, scale, tol)',)"
scipy,1.1.0,scipy.integrate._ivp.bdf.splu,integrate._ivp.bdf,splu,"Python Library Documentation: function splu in module scipy.sparse.linalg.dsolve.linsolve

splu(A, permc_spec=None, diag_pivot_thresh=None, relax=None, panel_size=None, options={})
    Compute the LU decomposition of a sparse, square matrix.
    
    Parameters
    ----------
    A : sparse matrix
        Sparse matrix to factorize. Should be in CSR or CSC format.
    permc_spec : str, optional
        How to permute the columns of the matrix for sparsity preservation.
        (default: 'COLAMD')
    
        - ``NATURAL``: natural ordering.
        - ``MMD_ATA``: minimum degree ordering on the structure of A^T A.
        - ``MMD_AT_PLUS_A``: minimum degree ordering on the structure of A^T+A.
        - ``COLAMD``: approximate minimum degree column ordering
    
    diag_pivot_thresh : float, optional
        Threshold used for a diagonal entry to be an acceptable pivot.
        See SuperLU user's guide for details [1]_
    relax : int, optional
        Expert option for customizing the degree of relaxing supernodes.
        See SuperLU user's guide for details [1]_
    panel_size : int, optional
        Expert option for customizing the panel size.
        See SuperLU user's guide for details [1]_
    options : dict, optional
        Dictionary containing additional expert options to SuperLU.
        See SuperLU user guide [1]_ (section 2.4 on the 'Options' argument)
        for more details. For example, you can specify
        ``options=dict(Equil=False, IterRefine='SINGLE'))``
        to turn equilibration off and perform a single iterative refinement.
    
    Returns
    -------
    invA : scipy.sparse.linalg.SuperLU
        Object, which has a ``solve`` method.
    
    See also
    --------
    spilu : incomplete LU decomposition
    
    Notes
    -----
    This function uses the SuperLU library.
    
    References
    ----------
    .. [1] SuperLU http://crd.lbl.gov/~xiaoye/SuperLU/
    
    Examples
    --------
    >>> from scipy.sparse import csc_matrix
    >>> from scipy.sparse.linalg import splu
    >>> A = csc_matrix([[1., 0., 0.], [5., 0., 2.], [0., -1., 0.]], dtype=float)
    >>> B = splu(A)
    >>> x = np.array([1., 2., 3.], dtype=float)
    >>> B.solve(x)
    array([ 1. , -3. , -1.5])
    >>> A.dot(B.solve(x))
    array([ 1.,  2.,  3.])
    >>> B.solve(A.dot(x))
    array([ 1.,  2.,  3.])
",function,"('(A, permc_spec=None, diag_pivot_thresh=None, relax=None, panel_size=None, options={})',)",scipy,1.1.0,scipy.integrate._ivp.bdf.splu,integrate._ivp.bdf,splu,"Python Library Documentation: function splu in module scipy.sparse.linalg.dsolve.linsolve

splu(A, permc_spec=None, diag_pivot_thresh=None, relax=None, panel_size=None, options={})
    Compute the LU decomposition of a sparse, square matrix.
    
    Parameters
    ----------
    A : sparse matrix
        Sparse matrix to factorize. Should be in CSR or CSC format.
    permc_spec : str, optional
        How to permute the columns of the matrix for sparsity preservation.
        (default: 'COLAMD')
    
        - ``NATURAL``: natural ordering.
        - ``MMD_ATA``: minimum degree ordering on the structure of A^T A.
        - ``MMD_AT_PLUS_A``: minimum degree ordering on the structure of A^T+A.
        - ``COLAMD``: approximate minimum degree column ordering
    
    diag_pivot_thresh : float, optional
        Threshold used for a diagonal entry to be an acceptable pivot.
        See SuperLU user's guide for details [1]_
    relax : int, optional
        Expert option for customizing the degree of relaxing supernodes.
        See SuperLU user's guide for details [1]_
    panel_size : int, optional
        Expert option for customizing the panel size.
        See SuperLU user's guide for details [1]_
    options : dict, optional
        Dictionary containing additional expert options to SuperLU.
        See SuperLU user guide [1]_ (section 2.4 on the 'Options' argument)
        for more details. For example, you can specify
        ``options=dict(Equil=False, IterRefine='SINGLE'))``
        to turn equilibration off and perform a single iterative refinement.
    
    Returns
    -------
    invA : scipy.sparse.linalg.SuperLU
        Object, which has a ``solve`` method.
    
    See also
    --------
    spilu : incomplete LU decomposition
    
    Notes
    -----
    This function uses the SuperLU library.
    
    References
    ----------
    .. [1] SuperLU http://crd.lbl.gov/~xiaoye/SuperLU/
    
    Examples
    --------
    >>> from scipy.sparse import csc_matrix
    >>> from scipy.sparse.linalg import splu
    >>> A = csc_matrix([[1., 0., 0.], [5., 0., 2.], [0., -1., 0.]], dtype=float)
    >>> B = splu(A)
    >>> x = np.array([1., 2., 3.], dtype=float)
    >>> B.solve(x)
    array([ 1. , -3. , -1.5])
    >>> A.dot(B.solve(x))
    array([ 1.,  2.,  3.])
    >>> B.solve(A.dot(x))
    array([ 1.,  2.,  3.])
",function,"('A', 'permc_spec', 'diag_pivot_thresh', 'relax', 'panel_size', 'options')","(nan, None, None, None, None, {})","(nan, 'NoneType', 'NoneType', 'NoneType', 'NoneType', 'dict')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(A, permc_spec=None, diag_pivot_thresh=None, relax=None, panel_size=None, options={})',)"
scipy,1.1.0,scipy.integrate._ivp.bdf.validate_max_step,integrate._ivp.bdf,validate_max_step,"Python Library Documentation: function validate_max_step in module scipy.integrate._ivp.common

validate_max_step(max_step)
    Assert that max_Step is valid and return it.
",function,"('(max_step)',)",scipy,1.1.0,scipy.integrate._ivp.bdf.validate_max_step,integrate._ivp.bdf,validate_max_step,"Python Library Documentation: function validate_max_step in module scipy.integrate._ivp.common

validate_max_step(max_step)
    Assert that max_Step is valid and return it.
",function,"('max_step',)","(nan,)","(nan,)","('arg_info',)","('(max_step)',)"
scipy,1.1.0,scipy.integrate._ivp.bdf.validate_tol,integrate._ivp.bdf,validate_tol,"Python Library Documentation: function validate_tol in module scipy.integrate._ivp.common

validate_tol(rtol, atol, n)
    Validate tolerance values.
",function,"('(rtol, atol, n)',)",scipy,1.1.0,scipy.integrate._ivp.bdf.validate_tol,integrate._ivp.bdf,validate_tol,"Python Library Documentation: function validate_tol in module scipy.integrate._ivp.common

validate_tol(rtol, atol, n)
    Validate tolerance values.
",function,"('rtol', 'atol', 'n')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(rtol, atol, n)',)"
scipy,1.1.0,scipy.integrate._ivp.bdf.warn_extraneous,integrate._ivp.bdf,warn_extraneous,"Python Library Documentation: function warn_extraneous in module scipy.integrate._ivp.common

warn_extraneous(extraneous)
    Display a warning for extraneous keyword arguments.
    
    The initializer of each solver class is expected to collect keyword
    arguments that it doesn't understand and warn about them. This function
    prints a warning for each key in the supplied dictionary.
    
    Parameters
    ----------
    extraneous : dict
        Extraneous keyword arguments
",function,"('(extraneous)',)",scipy,1.1.0,scipy.integrate._ivp.bdf.warn_extraneous,integrate._ivp.bdf,warn_extraneous,"Python Library Documentation: function warn_extraneous in module scipy.integrate._ivp.common

warn_extraneous(extraneous)
    Display a warning for extraneous keyword arguments.
    
    The initializer of each solver class is expected to collect keyword
    arguments that it doesn't understand and warn about them. This function
    prints a warning for each key in the supplied dictionary.
    
    Parameters
    ----------
    extraneous : dict
        Extraneous keyword arguments
",function,"('extraneous',)","(nan,)","(nan,)","('arg_info',)","('(extraneous)',)"
scipy,1.1.0,scipy.integrate._ivp.common.OdeSolution,integrate._ivp.common,OdeSolution,"Python Library Documentation: class OdeSolution in module scipy.integrate._ivp.common

class OdeSolution(builtins.object)
 |  Continuous ODE solution.
 |  
 |  It is organized as a collection of `DenseOutput` objects which represent
 |  local interpolants. It provides an algorithm to select a right interpolant
 |  for each given point.
 |  
 |  The interpolants cover the range between `t_min` and `t_max` (see
 |  Attributes below). Evaluation outside this interval is not forbidden, but
 |  the accuracy is not guaranteed.
 |  
 |  When evaluating at a breakpoint (one of the values in `ts`) a segment with
 |  the lower index is selected.
 |  
 |  Parameters
 |  ----------
 |  ts : array_like, shape (n_segments + 1,)
 |      Time instants between which local interpolants are defined. Must
 |      be strictly increasing or decreasing (zero segment with two points is
 |      also allowed).
 |  interpolants : list of DenseOutput with n_segments elements
 |      Local interpolants. An i-th interpolant is assumed to be defined
 |      between ``ts[i]`` and ``ts[i + 1]``.
 |  
 |  Attributes
 |  ----------
 |  t_min, t_max : float
 |      Time range of the interpolation.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, t)
 |      Evaluate the solution.
 |      
 |      Parameters
 |      ----------
 |      t : float or array_like with shape (n_points,)
 |          Points to evaluate at.
 |      
 |      Returns
 |      -------
 |      y : ndarray, shape (n_states,) or (n_states, n_points)
 |          Computed values. Shape depends on whether `t` is a scalar or a
 |          1-d array.
 |  
 |  __init__(self, ts, interpolants)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, ts, interpolants)',)",scipy,1.1.0,scipy.integrate._ivp.common.OdeSolution,integrate._ivp.common,OdeSolution,"Python Library Documentation: class OdeSolution in module scipy.integrate._ivp.common

class OdeSolution(builtins.object)
 |  Continuous ODE solution.
 |  
 |  It is organized as a collection of `DenseOutput` objects which represent
 |  local interpolants. It provides an algorithm to select a right interpolant
 |  for each given point.
 |  
 |  The interpolants cover the range between `t_min` and `t_max` (see
 |  Attributes below). Evaluation outside this interval is not forbidden, but
 |  the accuracy is not guaranteed.
 |  
 |  When evaluating at a breakpoint (one of the values in `ts`) a segment with
 |  the lower index is selected.
 |  
 |  Parameters
 |  ----------
 |  ts : array_like, shape (n_segments + 1,)
 |      Time instants between which local interpolants are defined. Must
 |      be strictly increasing or decreasing (zero segment with two points is
 |      also allowed).
 |  interpolants : list of DenseOutput with n_segments elements
 |      Local interpolants. An i-th interpolant is assumed to be defined
 |      between ``ts[i]`` and ``ts[i + 1]``.
 |  
 |  Attributes
 |  ----------
 |  t_min, t_max : float
 |      Time range of the interpolation.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, t)
 |      Evaluate the solution.
 |      
 |      Parameters
 |      ----------
 |      t : float or array_like with shape (n_points,)
 |          Points to evaluate at.
 |      
 |      Returns
 |      -------
 |      y : ndarray, shape (n_states,) or (n_states, n_points)
 |          Computed values. Shape depends on whether `t` is a scalar or a
 |          1-d array.
 |  
 |  __init__(self, ts, interpolants)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'ts', 'interpolants')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(self, ts, interpolants)',)"
scipy,1.1.0,scipy.integrate._ivp.common._dense_num_jac,integrate._ivp.common,_dense_num_jac,"Python Library Documentation: function _dense_num_jac in module scipy.integrate._ivp.common

_dense_num_jac(fun, t, y, f, h, factor, y_scale)
",function,"('(fun, t, y, f, h, factor, y_scale)',)",scipy,1.1.0,scipy.integrate._ivp.common._dense_num_jac,integrate._ivp.common,_dense_num_jac,"Python Library Documentation: function _dense_num_jac in module scipy.integrate._ivp.common

_dense_num_jac(fun, t, y, f, h, factor, y_scale)
",function,"('fun', 't', 'y', 'f', 'h', 'factor', 'y_scale')","(nan, nan, nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(fun, t, y, f, h, factor, y_scale)',)"
scipy,1.1.0,scipy.integrate._ivp.common._sparse_num_jac,integrate._ivp.common,_sparse_num_jac,"Python Library Documentation: function _sparse_num_jac in module scipy.integrate._ivp.common

_sparse_num_jac(fun, t, y, f, h, factor, y_scale, structure, groups)
",function,"('(fun, t, y, f, h, factor, y_scale, structure, groups)',)",scipy,1.1.0,scipy.integrate._ivp.common._sparse_num_jac,integrate._ivp.common,_sparse_num_jac,"Python Library Documentation: function _sparse_num_jac in module scipy.integrate._ivp.common

_sparse_num_jac(fun, t, y, f, h, factor, y_scale, structure, groups)
",function,"('fun', 't', 'y', 'f', 'h', 'factor', 'y_scale', 'structure', 'groups')","(nan, nan, nan, nan, nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(fun, t, y, f, h, factor, y_scale, structure, groups)',)"
scipy,1.1.0,scipy.integrate._ivp.common.coo_matrix,integrate._ivp.common,coo_matrix,"Python Library Documentation: class coo_matrix in module scipy.sparse.coo

class coo_matrix(scipy.sparse.data._data_matrix, scipy.sparse.data._minmax_mixin)
 |  A sparse matrix in COOrdinate format.
 |  
 |  Also known as the 'ijv' or 'triplet' format.
 |  
 |  This can be instantiated in several ways:
 |      coo_matrix(D)
 |          with a dense matrix D
 |  
 |      coo_matrix(S)
 |          with another sparse matrix S (equivalent to S.tocoo())
 |  
 |      coo_matrix((M, N), [dtype])
 |          to construct an empty matrix with shape (M, N)
 |          dtype is optional, defaulting to dtype='d'.
 |  
 |      coo_matrix((data, (i, j)), [shape=(M, N)])
 |          to construct from three arrays:
 |              1. data[:]   the entries of the matrix, in any order
 |              2. i[:]      the row indices of the matrix entries
 |              3. j[:]      the column indices of the matrix entries
 |  
 |          Where ``A[i[k], j[k]] = data[k]``.  When shape is not
 |          specified, it is inferred from the index arrays
 |  
 |  Attributes
 |  ----------
 |  dtype : dtype
 |      Data type of the matrix
 |  shape : 2-tuple
 |      Shape of the matrix
 |  ndim : int
 |      Number of dimensions (this is always 2)
 |  nnz
 |      Number of nonzero elements
 |  data
 |      COO format data array of the matrix
 |  row
 |      COO format row index array of the matrix
 |  col
 |      COO format column index array of the matrix
 |  
 |  Notes
 |  -----
 |  
 |  Sparse matrices can be used in arithmetic operations: they support
 |  addition, subtraction, multiplication, division, and matrix power.
 |  
 |  Advantages of the COO format
 |      - facilitates fast conversion among sparse formats
 |      - permits duplicate entries (see example)
 |      - very fast conversion to and from CSR/CSC formats
 |  
 |  Disadvantages of the COO format
 |      - does not directly support:
 |          + arithmetic operations
 |          + slicing
 |  
 |  Intended Usage
 |      - COO is a fast format for constructing sparse matrices
 |      - Once a matrix has been constructed, convert to CSR or
 |        CSC format for fast arithmetic and matrix vector operations
 |      - By default when converting to CSR or CSC format, duplicate (i,j)
 |        entries will be summed together.  This facilitates efficient
 |        construction of finite element matrices and the like. (see example)
 |  
 |  Examples
 |  --------
 |  
 |  >>> # Constructing an empty matrix
 |  >>> from scipy.sparse import coo_matrix
 |  >>> coo_matrix((3, 4), dtype=np.int8).toarray()
 |  array([[0, 0, 0, 0],
 |         [0, 0, 0, 0],
 |         [0, 0, 0, 0]], dtype=int8)
 |  
 |  >>> # Constructing a matrix using ijv format
 |  >>> row  = np.array([0, 3, 1, 0])
 |  >>> col  = np.array([0, 3, 1, 2])
 |  >>> data = np.array([4, 5, 7, 9])
 |  >>> coo_matrix((data, (row, col)), shape=(4, 4)).toarray()
 |  array([[4, 0, 9, 0],
 |         [0, 7, 0, 0],
 |         [0, 0, 0, 0],
 |         [0, 0, 0, 5]])
 |  
 |  >>> # Constructing a matrix with duplicate indices
 |  >>> row  = np.array([0, 0, 1, 3, 1, 0, 0])
 |  >>> col  = np.array([0, 2, 1, 3, 1, 0, 0])
 |  >>> data = np.array([1, 1, 1, 1, 1, 1, 1])
 |  >>> coo = coo_matrix((data, (row, col)), shape=(4, 4))
 |  >>> # Duplicate indices are maintained until implicitly or explicitly summed
 |  >>> np.max(coo.data)
 |  1
 |  >>> coo.toarray()
 |  array([[3, 0, 1, 0],
 |         [0, 2, 0, 0],
 |         [0, 0, 0, 0],
 |         [0, 0, 0, 1]])
 |  
 |  Method resolution order:
 |      coo_matrix
 |      scipy.sparse.data._data_matrix
 |      scipy.sparse.base.spmatrix
 |      scipy.sparse.data._minmax_mixin
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, arg1, shape=None, dtype=None, copy=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  diagonal(self, k=0)
 |      Returns the k-th diagonal of the matrix.
 |      
 |      Parameters
 |      ----------
 |      k : int, optional
 |          Which diagonal to set, corresponding to elements a[i, i+k].
 |          Default: 0 (the main diagonal).
 |      
 |          .. versionadded:: 1.0
 |      
 |      See also
 |      --------
 |      numpy.diagonal : Equivalent numpy function.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> A.diagonal()
 |      array([1, 0, 5])
 |      >>> A.diagonal(k=1)
 |      array([2, 3])
 |  
 |  eliminate_zeros(self)
 |      Remove zero entries from the matrix
 |      
 |      This is an *in place* operation
 |  
 |  getnnz(self, axis=None)
 |      Number of stored values, including explicit zeros.
 |      
 |      Parameters
 |      ----------
 |      axis : None, 0, or 1
 |          Select between the number of values across the whole matrix, in
 |          each column, or in each row.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  reshape(self, *args, **kwargs)
 |      reshape(self, shape, order='C', copy=False)
 |      
 |      Gives a new shape to a sparse matrix without changing its data.
 |      
 |      Parameters
 |      ----------
 |      shape : length-2 tuple of ints
 |          The new shape should be compatible with the original shape.
 |      order : {'C', 'F'}, optional
 |          Read the elements using this index order. 'C' means to read and
 |          write the elements using C-like index order; e.g. read entire first
 |          row, then second row, etc. 'F' means to read and write the elements
 |          using Fortran-like index order; e.g. read entire first column, then
 |          second column, etc.
 |      copy : bool, optional
 |          Indicates whether or not attributes of self should be copied
 |          whenever possible. The degree to which attributes are copied varies
 |          depending on the type of sparse matrix being used.
 |      
 |      Returns
 |      -------
 |      reshaped_matrix : sparse matrix
 |          A sparse matrix with the given `shape`, not necessarily of the same
 |          format as the current object.
 |      
 |      See Also
 |      --------
 |      np.matrix.reshape : NumPy's implementation of 'reshape' for matrices
 |  
 |  resize(self, *shape)
 |      Resize the matrix in-place to dimensions given by ``shape``
 |      
 |      Any elements that lie within the new shape will remain at the same
 |      indices, while non-zero elements lying outside the new shape are
 |      removed.
 |      
 |      Parameters
 |      ----------
 |      shape : (int, int)
 |          number of rows and columns in the new matrix
 |      
 |      Notes
 |      -----
 |      The semantics are not identical to `numpy.ndarray.resize` or
 |      `numpy.resize`.  Here, the same data will be maintained at each index
 |      before and after reshape, if that index is within the new bounds.  In
 |      numpy, resizing maintains contiguity of the array, moving elements
 |      around in the logical matrix but not within a flattened representation.
 |      
 |      We give no guarantees about whether the underlying data attributes
 |      (arrays, etc.) will be modified in place or replaced with new objects.
 |  
 |  sum_duplicates(self)
 |      Eliminate duplicate matrix entries by adding them together
 |      
 |      This is an *in place* operation
 |  
 |  toarray(self, order=None, out=None)
 |      See the docstring for `spmatrix.toarray`.
 |  
 |  tocoo(self, copy=False)
 |      Convert this matrix to COOrdinate format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant coo_matrix.
 |  
 |  tocsc(self, copy=False)
 |      Convert this matrix to Compressed Sparse Column format
 |      
 |      Duplicate entries will be summed together.
 |      
 |      Examples
 |      --------
 |      >>> from numpy import array
 |      >>> from scipy.sparse import coo_matrix
 |      >>> row  = array([0, 0, 1, 3, 1, 0, 0])
 |      >>> col  = array([0, 2, 1, 3, 1, 0, 0])
 |      >>> data = array([1, 1, 1, 1, 1, 1, 1])
 |      >>> A = coo_matrix((data, (row, col)), shape=(4, 4)).tocsc()
 |      >>> A.toarray()
 |      array([[3, 0, 1, 0],
 |             [0, 2, 0, 0],
 |             [0, 0, 0, 0],
 |             [0, 0, 0, 1]])
 |  
 |  tocsr(self, copy=False)
 |      Convert this matrix to Compressed Sparse Row format
 |      
 |      Duplicate entries will be summed together.
 |      
 |      Examples
 |      --------
 |      >>> from numpy import array
 |      >>> from scipy.sparse import coo_matrix
 |      >>> row  = array([0, 0, 1, 3, 1, 0, 0])
 |      >>> col  = array([0, 2, 1, 3, 1, 0, 0])
 |      >>> data = array([1, 1, 1, 1, 1, 1, 1])
 |      >>> A = coo_matrix((data, (row, col)), shape=(4, 4)).tocsr()
 |      >>> A.toarray()
 |      array([[3, 0, 1, 0],
 |             [0, 2, 0, 0],
 |             [0, 0, 0, 0],
 |             [0, 0, 0, 1]])
 |  
 |  todia(self, copy=False)
 |      Convert this matrix to sparse DIAgonal format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dia_matrix.
 |  
 |  todok(self, copy=False)
 |      Convert this matrix to Dictionary Of Keys format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dok_matrix.
 |  
 |  transpose(self, axes=None, copy=False)
 |      Reverses the dimensions of the sparse matrix.
 |      
 |      Parameters
 |      ----------
 |      axes : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value.
 |      copy : bool, optional
 |          Indicates whether or not attributes of `self` should be
 |          copied whenever possible. The degree to which attributes
 |          are copied varies depending on the type of sparse matrix
 |          being used.
 |      
 |      Returns
 |      -------
 |      p : `self` with the dimensions reversed.
 |      
 |      See Also
 |      --------
 |      np.matrix.transpose : NumPy's implementation of 'transpose'
 |                            for matrices
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  format = 'coo'
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._data_matrix:
 |  
 |  __abs__(self)
 |  
 |  __imul__(self, other)
 |  
 |  __itruediv__(self, other)
 |  
 |  __neg__(self)
 |  
 |  arcsin(self)
 |      Element-wise arcsin.
 |      
 |      See numpy.arcsin for more information.
 |  
 |  arcsinh(self)
 |      Element-wise arcsinh.
 |      
 |      See numpy.arcsinh for more information.
 |  
 |  arctan(self)
 |      Element-wise arctan.
 |      
 |      See numpy.arctan for more information.
 |  
 |  arctanh(self)
 |      Element-wise arctanh.
 |      
 |      See numpy.arctanh for more information.
 |  
 |  astype(self, dtype, casting='unsafe', copy=True)
 |      Cast the matrix elements to a specified type.
 |      
 |      Parameters
 |      ----------
 |      dtype : string or numpy dtype
 |          Typecode or data-type to which to cast the data.
 |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
 |          Controls what kind of data casting may occur.
 |          Defaults to 'unsafe' for backwards compatibility.
 |          'no' means the data types should not be cast at all.
 |          'equiv' means only byte-order changes are allowed.
 |          'safe' means only casts which can preserve values are allowed.
 |          'same_kind' means only safe casts or casts within a kind,
 |          like float64 to float32, are allowed.
 |          'unsafe' means any data conversions may be done.
 |      copy : bool, optional
 |          If `copy` is `False`, the result might share some memory with this
 |          matrix. If `copy` is `True`, it is guaranteed that the result and
 |          this matrix do not share any memory.
 |  
 |  ceil(self)
 |      Element-wise ceil.
 |      
 |      See numpy.ceil for more information.
 |  
 |  conj(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  copy(self)
 |      Returns a copy of this matrix.
 |      
 |      No data/indices will be shared between the returned value and current
 |      matrix.
 |  
 |  count_nonzero(self)
 |      Number of non-zero entries, equivalent to
 |      
 |      np.count_nonzero(a.toarray())
 |      
 |      Unlike getnnz() and the nnz property, which return the number of stored
 |      entries (the length of the data attribute), this method counts the
 |      actual number of non-zero entries in data.
 |  
 |  deg2rad(self)
 |      Element-wise deg2rad.
 |      
 |      See numpy.deg2rad for more information.
 |  
 |  expm1(self)
 |      Element-wise expm1.
 |      
 |      See numpy.expm1 for more information.
 |  
 |  floor(self)
 |      Element-wise floor.
 |      
 |      See numpy.floor for more information.
 |  
 |  log1p(self)
 |      Element-wise log1p.
 |      
 |      See numpy.log1p for more information.
 |  
 |  power(self, n, dtype=None)
 |      This function performs element-wise power.
 |      
 |      Parameters
 |      ----------
 |      n : n is a scalar
 |      
 |      dtype : If dtype is not specified, the current dtype will be preserved.
 |  
 |  rad2deg(self)
 |      Element-wise rad2deg.
 |      
 |      See numpy.rad2deg for more information.
 |  
 |  rint(self)
 |      Element-wise rint.
 |      
 |      See numpy.rint for more information.
 |  
 |  sign(self)
 |      Element-wise sign.
 |      
 |      See numpy.sign for more information.
 |  
 |  sin(self)
 |      Element-wise sin.
 |      
 |      See numpy.sin for more information.
 |  
 |  sinh(self)
 |      Element-wise sinh.
 |      
 |      See numpy.sinh for more information.
 |  
 |  sqrt(self)
 |      Element-wise sqrt.
 |      
 |      See numpy.sqrt for more information.
 |  
 |  tan(self)
 |      Element-wise tan.
 |      
 |      See numpy.tan for more information.
 |  
 |  tanh(self)
 |      Element-wise tanh.
 |      
 |      See numpy.tanh for more information.
 |  
 |  trunc(self)
 |      Element-wise trunc.
 |      
 |      See numpy.trunc for more information.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.data._data_matrix:
 |  
 |  dtype
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.base.spmatrix:
 |  
 |  __add__(self, other)
 |  
 |  __bool__(self)
 |  
 |  __div__(self, other)
 |  
 |  __eq__(self, other)
 |      Return self==value.
 |  
 |  __ge__(self, other)
 |      Return self>=value.
 |  
 |  __getattr__(self, attr)
 |  
 |  __gt__(self, other)
 |      Return self>value.
 |  
 |  __iadd__(self, other)
 |  
 |  __idiv__(self, other)
 |  
 |  __isub__(self, other)
 |  
 |  __iter__(self)
 |  
 |  __le__(self, other)
 |      Return self<=value.
 |  
 |  __len__(self)
 |      # What should len(sparse) return? For consistency with dense matrices,
 |      # perhaps it should be the number of rows?  But for some uses the number of
 |      # non-zeros is more important.  For now, raise an exception!
 |  
 |  __lt__(self, other)
 |      Return self<value.
 |  
 |  __matmul__(self, other)
 |  
 |  __mul__(self, other)
 |      interpret other and call one of the following
 |      
 |      self._mul_scalar()
 |      self._mul_vector()
 |      self._mul_multivector()
 |      self._mul_sparse_matrix()
 |  
 |  __ne__(self, other)
 |      Return self!=value.
 |  
 |  __nonzero__ = __bool__(self)
 |  
 |  __pow__(self, other)
 |  
 |  __radd__(self, other)
 |  
 |  __rdiv__(self, other)
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __rmatmul__(self, other)
 |  
 |  __rmul__(self, other)
 |  
 |  __rsub__(self, other)
 |  
 |  __rtruediv__(self, other)
 |  
 |  __str__(self)
 |      Return str(self).
 |  
 |  __sub__(self, other)
 |  
 |  __truediv__(self, other)
 |  
 |  asformat(self, format, copy=False)
 |      Return this matrix in the passed sparse format.
 |      
 |      Parameters
 |      ----------
 |      format : {str, None}
 |          The desired sparse matrix format (""csr"", ""csc"", ""lil"", ""dok"", ...)
 |          or None for no conversion.
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : This matrix in the passed sparse format.
 |  
 |  asfptype(self)
 |      Upcast matrix to a floating point format (if necessary)
 |  
 |  conjugate(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  dot(self, other)
 |      Ordinary dot product
 |      
 |      Examples
 |      --------
 |      >>> import numpy as np
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> v = np.array([1, 0, -1])
 |      >>> A.dot(v)
 |      array([ 1, -3, -1], dtype=int64)
 |  
 |  getH(self)
 |      Return the Hermitian transpose of this matrix.
 |      
 |      See Also
 |      --------
 |      np.matrix.getH : NumPy's implementation of `getH` for matrices
 |  
 |  get_shape(self)
 |      Get shape of a matrix.
 |  
 |  getcol(self, j)
 |      Returns a copy of column j of the matrix, as an (m x 1) sparse
 |      matrix (column vector).
 |  
 |  getformat(self)
 |      Format of a matrix representation as a string.
 |  
 |  getmaxprint(self)
 |      Maximum number of elements to display when printed.
 |  
 |  getrow(self, i)
 |      Returns a copy of row i of the matrix, as a (1 x n) sparse
 |      matrix (row vector).
 |  
 |  maximum(self, other)
 |      Element-wise maximum between this and another matrix.
 |  
 |  mean(self, axis=None, dtype=None, out=None)
 |      Compute the arithmetic mean along the specified axis.
 |      
 |      Returns the average of the matrix elements. The average is taken
 |      over all elements in the matrix by default, otherwise over the
 |      specified axis. `float64` intermediate and return values are used
 |      for integer inputs.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the mean is computed. The default is to compute
 |          the mean of all elements in the matrix (i.e. `axis` = `None`).
 |      dtype : data-type, optional
 |          Type to use in computing the mean. For integer inputs, the default
 |          is `float64`; for floating point inputs, it is the same as the
 |          input dtype.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      m : np.matrix
 |      
 |      See Also
 |      --------
 |      np.matrix.mean : NumPy's implementation of 'mean' for matrices
 |  
 |  minimum(self, other)
 |      Element-wise minimum between this and another matrix.
 |  
 |  multiply(self, other)
 |      Point-wise multiplication by another matrix
 |  
 |  nonzero(self)
 |      nonzero indices
 |      
 |      Returns a tuple of arrays (row,col) containing the indices
 |      of the non-zero elements of the matrix.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1,2,0],[0,0,3],[4,0,5]])
 |      >>> A.nonzero()
 |      (array([0, 0, 1, 2, 2]), array([0, 1, 2, 0, 2]))
 |  
 |  set_shape(self, shape)
 |      See `reshape`.
 |  
 |  setdiag(self, values, k=0)
 |      Set diagonal or off-diagonal elements of the array.
 |      
 |      Parameters
 |      ----------
 |      values : array_like
 |          New values of the diagonal elements.
 |      
 |          Values may have any length.  If the diagonal is longer than values,
 |          then the remaining diagonal entries will not be set.  If values if
 |          longer than the diagonal, then the remaining values are ignored.
 |      
 |          If a scalar value is given, all of the diagonal is set to it.
 |      
 |      k : int, optional
 |          Which off-diagonal to set, corresponding to elements a[i,i+k].
 |          Default: 0 (the main diagonal).
 |  
 |  sum(self, axis=None, dtype=None, out=None)
 |      Sum the matrix elements over a given axis.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the sum of all the matrix elements, returning a scalar
 |          (i.e. `axis` = `None`).
 |      dtype : dtype, optional
 |          The type of the returned matrix and of the accumulator in which
 |          the elements are summed.  The dtype of `a` is used by default
 |          unless `a` has an integer dtype of less precision than the default
 |          platform integer.  In that case, if `a` is signed then the platform
 |          integer is used while if `a` is unsigned then an unsigned integer
 |          of the same precision as the platform integer is used.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      sum_along_axis : np.matrix
 |          A matrix with the same shape as `self`, with the specified
 |          axis removed.
 |      
 |      See Also
 |      --------
 |      np.matrix.sum : NumPy's implementation of 'sum' for matrices
 |  
 |  tobsr(self, blocksize=None, copy=False)
 |      Convert this matrix to Block Sparse Row format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant bsr_matrix.
 |      
 |      When blocksize=(R, C) is provided, it will be used for construction of
 |      the bsr_matrix.
 |  
 |  todense(self, order=None, out=None)
 |      Return a dense matrix representation of this matrix.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F'}, optional
 |          Whether to store multi-dimensional data in C (row-major)
 |          or Fortran (column-major) order in memory. The default
 |          is 'None', indicating the NumPy default of C-ordered.
 |          Cannot be specified in conjunction with the `out`
 |          argument.
 |      
 |      out : ndarray, 2-dimensional, optional
 |          If specified, uses this array (or `numpy.matrix`) as the
 |          output buffer instead of allocating a new array to
 |          return. The provided array must have the same shape and
 |          dtype as the sparse matrix on which you are calling the
 |          method.
 |      
 |      Returns
 |      -------
 |      arr : numpy.matrix, 2-dimensional
 |          A NumPy matrix object with the same shape and containing
 |          the same data represented by the sparse matrix, with the
 |          requested memory order. If `out` was passed and was an
 |          array (rather than a `numpy.matrix`), it will be filled
 |          with the appropriate values and returned wrapped in a
 |          `numpy.matrix` object that shares the same memory.
 |  
 |  tolil(self, copy=False)
 |      Convert this matrix to LInked List format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant lil_matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.base.spmatrix:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  nnz
 |      Number of stored values, including explicit zeros.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  shape
 |      Get shape of a matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.sparse.base.spmatrix:
 |  
 |  __array_priority__ = 10.1
 |  
 |  __hash__ = None
 |  
 |  ndim = 2
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._minmax_mixin:
 |  
 |  argmax(self, axis=None, out=None)
 |      Return indices of maximum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several maximum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmax is computed. If None (default), index
 |          of the maximum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      ind : np.matrix or int
 |          Indices of maximum elements. If matrix, its size along `axis` is 1.
 |  
 |  argmin(self, axis=None, out=None)
 |      Return indices of minimum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several minimum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmin is computed. If None (default), index
 |          of the minimum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |       ind : np.matrix or int
 |          Indices of minimum elements. If matrix, its size along `axis` is 1.
 |  
 |  max(self, axis=None, out=None)
 |      Return the maximum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the maximum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amax : coo_matrix or scalar
 |          Maximum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      min : The minimum value of a sparse matrix along a given axis.
 |      np.matrix.max : NumPy's implementation of 'max' for matrices
 |  
 |  min(self, axis=None, out=None)
 |      Return the minimum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the minimum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amin : coo_matrix or scalar
 |          Minimum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      max : The maximum value of a sparse matrix along a given axis.
 |      np.matrix.min : NumPy's implementation of 'min' for matrices
",class,"('(self, arg1, shape=None, dtype=None, copy=False)',)",scipy,1.1.0,scipy.integrate._ivp.common.coo_matrix,integrate._ivp.common,coo_matrix,"Python Library Documentation: class coo_matrix in module scipy.sparse.coo

class coo_matrix(scipy.sparse.data._data_matrix, scipy.sparse.data._minmax_mixin)
 |  A sparse matrix in COOrdinate format.
 |  
 |  Also known as the 'ijv' or 'triplet' format.
 |  
 |  This can be instantiated in several ways:
 |      coo_matrix(D)
 |          with a dense matrix D
 |  
 |      coo_matrix(S)
 |          with another sparse matrix S (equivalent to S.tocoo())
 |  
 |      coo_matrix((M, N), [dtype])
 |          to construct an empty matrix with shape (M, N)
 |          dtype is optional, defaulting to dtype='d'.
 |  
 |      coo_matrix((data, (i, j)), [shape=(M, N)])
 |          to construct from three arrays:
 |              1. data[:]   the entries of the matrix, in any order
 |              2. i[:]      the row indices of the matrix entries
 |              3. j[:]      the column indices of the matrix entries
 |  
 |          Where ``A[i[k], j[k]] = data[k]``.  When shape is not
 |          specified, it is inferred from the index arrays
 |  
 |  Attributes
 |  ----------
 |  dtype : dtype
 |      Data type of the matrix
 |  shape : 2-tuple
 |      Shape of the matrix
 |  ndim : int
 |      Number of dimensions (this is always 2)
 |  nnz
 |      Number of nonzero elements
 |  data
 |      COO format data array of the matrix
 |  row
 |      COO format row index array of the matrix
 |  col
 |      COO format column index array of the matrix
 |  
 |  Notes
 |  -----
 |  
 |  Sparse matrices can be used in arithmetic operations: they support
 |  addition, subtraction, multiplication, division, and matrix power.
 |  
 |  Advantages of the COO format
 |      - facilitates fast conversion among sparse formats
 |      - permits duplicate entries (see example)
 |      - very fast conversion to and from CSR/CSC formats
 |  
 |  Disadvantages of the COO format
 |      - does not directly support:
 |          + arithmetic operations
 |          + slicing
 |  
 |  Intended Usage
 |      - COO is a fast format for constructing sparse matrices
 |      - Once a matrix has been constructed, convert to CSR or
 |        CSC format for fast arithmetic and matrix vector operations
 |      - By default when converting to CSR or CSC format, duplicate (i,j)
 |        entries will be summed together.  This facilitates efficient
 |        construction of finite element matrices and the like. (see example)
 |  
 |  Examples
 |  --------
 |  
 |  >>> # Constructing an empty matrix
 |  >>> from scipy.sparse import coo_matrix
 |  >>> coo_matrix((3, 4), dtype=np.int8).toarray()
 |  array([[0, 0, 0, 0],
 |         [0, 0, 0, 0],
 |         [0, 0, 0, 0]], dtype=int8)
 |  
 |  >>> # Constructing a matrix using ijv format
 |  >>> row  = np.array([0, 3, 1, 0])
 |  >>> col  = np.array([0, 3, 1, 2])
 |  >>> data = np.array([4, 5, 7, 9])
 |  >>> coo_matrix((data, (row, col)), shape=(4, 4)).toarray()
 |  array([[4, 0, 9, 0],
 |         [0, 7, 0, 0],
 |         [0, 0, 0, 0],
 |         [0, 0, 0, 5]])
 |  
 |  >>> # Constructing a matrix with duplicate indices
 |  >>> row  = np.array([0, 0, 1, 3, 1, 0, 0])
 |  >>> col  = np.array([0, 2, 1, 3, 1, 0, 0])
 |  >>> data = np.array([1, 1, 1, 1, 1, 1, 1])
 |  >>> coo = coo_matrix((data, (row, col)), shape=(4, 4))
 |  >>> # Duplicate indices are maintained until implicitly or explicitly summed
 |  >>> np.max(coo.data)
 |  1
 |  >>> coo.toarray()
 |  array([[3, 0, 1, 0],
 |         [0, 2, 0, 0],
 |         [0, 0, 0, 0],
 |         [0, 0, 0, 1]])
 |  
 |  Method resolution order:
 |      coo_matrix
 |      scipy.sparse.data._data_matrix
 |      scipy.sparse.base.spmatrix
 |      scipy.sparse.data._minmax_mixin
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, arg1, shape=None, dtype=None, copy=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  diagonal(self, k=0)
 |      Returns the k-th diagonal of the matrix.
 |      
 |      Parameters
 |      ----------
 |      k : int, optional
 |          Which diagonal to set, corresponding to elements a[i, i+k].
 |          Default: 0 (the main diagonal).
 |      
 |          .. versionadded:: 1.0
 |      
 |      See also
 |      --------
 |      numpy.diagonal : Equivalent numpy function.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> A.diagonal()
 |      array([1, 0, 5])
 |      >>> A.diagonal(k=1)
 |      array([2, 3])
 |  
 |  eliminate_zeros(self)
 |      Remove zero entries from the matrix
 |      
 |      This is an *in place* operation
 |  
 |  getnnz(self, axis=None)
 |      Number of stored values, including explicit zeros.
 |      
 |      Parameters
 |      ----------
 |      axis : None, 0, or 1
 |          Select between the number of values across the whole matrix, in
 |          each column, or in each row.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  reshape(self, *args, **kwargs)
 |      reshape(self, shape, order='C', copy=False)
 |      
 |      Gives a new shape to a sparse matrix without changing its data.
 |      
 |      Parameters
 |      ----------
 |      shape : length-2 tuple of ints
 |          The new shape should be compatible with the original shape.
 |      order : {'C', 'F'}, optional
 |          Read the elements using this index order. 'C' means to read and
 |          write the elements using C-like index order; e.g. read entire first
 |          row, then second row, etc. 'F' means to read and write the elements
 |          using Fortran-like index order; e.g. read entire first column, then
 |          second column, etc.
 |      copy : bool, optional
 |          Indicates whether or not attributes of self should be copied
 |          whenever possible. The degree to which attributes are copied varies
 |          depending on the type of sparse matrix being used.
 |      
 |      Returns
 |      -------
 |      reshaped_matrix : sparse matrix
 |          A sparse matrix with the given `shape`, not necessarily of the same
 |          format as the current object.
 |      
 |      See Also
 |      --------
 |      np.matrix.reshape : NumPy's implementation of 'reshape' for matrices
 |  
 |  resize(self, *shape)
 |      Resize the matrix in-place to dimensions given by ``shape``
 |      
 |      Any elements that lie within the new shape will remain at the same
 |      indices, while non-zero elements lying outside the new shape are
 |      removed.
 |      
 |      Parameters
 |      ----------
 |      shape : (int, int)
 |          number of rows and columns in the new matrix
 |      
 |      Notes
 |      -----
 |      The semantics are not identical to `numpy.ndarray.resize` or
 |      `numpy.resize`.  Here, the same data will be maintained at each index
 |      before and after reshape, if that index is within the new bounds.  In
 |      numpy, resizing maintains contiguity of the array, moving elements
 |      around in the logical matrix but not within a flattened representation.
 |      
 |      We give no guarantees about whether the underlying data attributes
 |      (arrays, etc.) will be modified in place or replaced with new objects.
 |  
 |  sum_duplicates(self)
 |      Eliminate duplicate matrix entries by adding them together
 |      
 |      This is an *in place* operation
 |  
 |  toarray(self, order=None, out=None)
 |      See the docstring for `spmatrix.toarray`.
 |  
 |  tocoo(self, copy=False)
 |      Convert this matrix to COOrdinate format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant coo_matrix.
 |  
 |  tocsc(self, copy=False)
 |      Convert this matrix to Compressed Sparse Column format
 |      
 |      Duplicate entries will be summed together.
 |      
 |      Examples
 |      --------
 |      >>> from numpy import array
 |      >>> from scipy.sparse import coo_matrix
 |      >>> row  = array([0, 0, 1, 3, 1, 0, 0])
 |      >>> col  = array([0, 2, 1, 3, 1, 0, 0])
 |      >>> data = array([1, 1, 1, 1, 1, 1, 1])
 |      >>> A = coo_matrix((data, (row, col)), shape=(4, 4)).tocsc()
 |      >>> A.toarray()
 |      array([[3, 0, 1, 0],
 |             [0, 2, 0, 0],
 |             [0, 0, 0, 0],
 |             [0, 0, 0, 1]])
 |  
 |  tocsr(self, copy=False)
 |      Convert this matrix to Compressed Sparse Row format
 |      
 |      Duplicate entries will be summed together.
 |      
 |      Examples
 |      --------
 |      >>> from numpy import array
 |      >>> from scipy.sparse import coo_matrix
 |      >>> row  = array([0, 0, 1, 3, 1, 0, 0])
 |      >>> col  = array([0, 2, 1, 3, 1, 0, 0])
 |      >>> data = array([1, 1, 1, 1, 1, 1, 1])
 |      >>> A = coo_matrix((data, (row, col)), shape=(4, 4)).tocsr()
 |      >>> A.toarray()
 |      array([[3, 0, 1, 0],
 |             [0, 2, 0, 0],
 |             [0, 0, 0, 0],
 |             [0, 0, 0, 1]])
 |  
 |  todia(self, copy=False)
 |      Convert this matrix to sparse DIAgonal format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dia_matrix.
 |  
 |  todok(self, copy=False)
 |      Convert this matrix to Dictionary Of Keys format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dok_matrix.
 |  
 |  transpose(self, axes=None, copy=False)
 |      Reverses the dimensions of the sparse matrix.
 |      
 |      Parameters
 |      ----------
 |      axes : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value.
 |      copy : bool, optional
 |          Indicates whether or not attributes of `self` should be
 |          copied whenever possible. The degree to which attributes
 |          are copied varies depending on the type of sparse matrix
 |          being used.
 |      
 |      Returns
 |      -------
 |      p : `self` with the dimensions reversed.
 |      
 |      See Also
 |      --------
 |      np.matrix.transpose : NumPy's implementation of 'transpose'
 |                            for matrices
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  format = 'coo'
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._data_matrix:
 |  
 |  __abs__(self)
 |  
 |  __imul__(self, other)
 |  
 |  __itruediv__(self, other)
 |  
 |  __neg__(self)
 |  
 |  arcsin(self)
 |      Element-wise arcsin.
 |      
 |      See numpy.arcsin for more information.
 |  
 |  arcsinh(self)
 |      Element-wise arcsinh.
 |      
 |      See numpy.arcsinh for more information.
 |  
 |  arctan(self)
 |      Element-wise arctan.
 |      
 |      See numpy.arctan for more information.
 |  
 |  arctanh(self)
 |      Element-wise arctanh.
 |      
 |      See numpy.arctanh for more information.
 |  
 |  astype(self, dtype, casting='unsafe', copy=True)
 |      Cast the matrix elements to a specified type.
 |      
 |      Parameters
 |      ----------
 |      dtype : string or numpy dtype
 |          Typecode or data-type to which to cast the data.
 |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
 |          Controls what kind of data casting may occur.
 |          Defaults to 'unsafe' for backwards compatibility.
 |          'no' means the data types should not be cast at all.
 |          'equiv' means only byte-order changes are allowed.
 |          'safe' means only casts which can preserve values are allowed.
 |          'same_kind' means only safe casts or casts within a kind,
 |          like float64 to float32, are allowed.
 |          'unsafe' means any data conversions may be done.
 |      copy : bool, optional
 |          If `copy` is `False`, the result might share some memory with this
 |          matrix. If `copy` is `True`, it is guaranteed that the result and
 |          this matrix do not share any memory.
 |  
 |  ceil(self)
 |      Element-wise ceil.
 |      
 |      See numpy.ceil for more information.
 |  
 |  conj(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  copy(self)
 |      Returns a copy of this matrix.
 |      
 |      No data/indices will be shared between the returned value and current
 |      matrix.
 |  
 |  count_nonzero(self)
 |      Number of non-zero entries, equivalent to
 |      
 |      np.count_nonzero(a.toarray())
 |      
 |      Unlike getnnz() and the nnz property, which return the number of stored
 |      entries (the length of the data attribute), this method counts the
 |      actual number of non-zero entries in data.
 |  
 |  deg2rad(self)
 |      Element-wise deg2rad.
 |      
 |      See numpy.deg2rad for more information.
 |  
 |  expm1(self)
 |      Element-wise expm1.
 |      
 |      See numpy.expm1 for more information.
 |  
 |  floor(self)
 |      Element-wise floor.
 |      
 |      See numpy.floor for more information.
 |  
 |  log1p(self)
 |      Element-wise log1p.
 |      
 |      See numpy.log1p for more information.
 |  
 |  power(self, n, dtype=None)
 |      This function performs element-wise power.
 |      
 |      Parameters
 |      ----------
 |      n : n is a scalar
 |      
 |      dtype : If dtype is not specified, the current dtype will be preserved.
 |  
 |  rad2deg(self)
 |      Element-wise rad2deg.
 |      
 |      See numpy.rad2deg for more information.
 |  
 |  rint(self)
 |      Element-wise rint.
 |      
 |      See numpy.rint for more information.
 |  
 |  sign(self)
 |      Element-wise sign.
 |      
 |      See numpy.sign for more information.
 |  
 |  sin(self)
 |      Element-wise sin.
 |      
 |      See numpy.sin for more information.
 |  
 |  sinh(self)
 |      Element-wise sinh.
 |      
 |      See numpy.sinh for more information.
 |  
 |  sqrt(self)
 |      Element-wise sqrt.
 |      
 |      See numpy.sqrt for more information.
 |  
 |  tan(self)
 |      Element-wise tan.
 |      
 |      See numpy.tan for more information.
 |  
 |  tanh(self)
 |      Element-wise tanh.
 |      
 |      See numpy.tanh for more information.
 |  
 |  trunc(self)
 |      Element-wise trunc.
 |      
 |      See numpy.trunc for more information.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.data._data_matrix:
 |  
 |  dtype
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.base.spmatrix:
 |  
 |  __add__(self, other)
 |  
 |  __bool__(self)
 |  
 |  __div__(self, other)
 |  
 |  __eq__(self, other)
 |      Return self==value.
 |  
 |  __ge__(self, other)
 |      Return self>=value.
 |  
 |  __getattr__(self, attr)
 |  
 |  __gt__(self, other)
 |      Return self>value.
 |  
 |  __iadd__(self, other)
 |  
 |  __idiv__(self, other)
 |  
 |  __isub__(self, other)
 |  
 |  __iter__(self)
 |  
 |  __le__(self, other)
 |      Return self<=value.
 |  
 |  __len__(self)
 |      # What should len(sparse) return? For consistency with dense matrices,
 |      # perhaps it should be the number of rows?  But for some uses the number of
 |      # non-zeros is more important.  For now, raise an exception!
 |  
 |  __lt__(self, other)
 |      Return self<value.
 |  
 |  __matmul__(self, other)
 |  
 |  __mul__(self, other)
 |      interpret other and call one of the following
 |      
 |      self._mul_scalar()
 |      self._mul_vector()
 |      self._mul_multivector()
 |      self._mul_sparse_matrix()
 |  
 |  __ne__(self, other)
 |      Return self!=value.
 |  
 |  __nonzero__ = __bool__(self)
 |  
 |  __pow__(self, other)
 |  
 |  __radd__(self, other)
 |  
 |  __rdiv__(self, other)
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __rmatmul__(self, other)
 |  
 |  __rmul__(self, other)
 |  
 |  __rsub__(self, other)
 |  
 |  __rtruediv__(self, other)
 |  
 |  __str__(self)
 |      Return str(self).
 |  
 |  __sub__(self, other)
 |  
 |  __truediv__(self, other)
 |  
 |  asformat(self, format, copy=False)
 |      Return this matrix in the passed sparse format.
 |      
 |      Parameters
 |      ----------
 |      format : {str, None}
 |          The desired sparse matrix format (""csr"", ""csc"", ""lil"", ""dok"", ...)
 |          or None for no conversion.
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : This matrix in the passed sparse format.
 |  
 |  asfptype(self)
 |      Upcast matrix to a floating point format (if necessary)
 |  
 |  conjugate(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  dot(self, other)
 |      Ordinary dot product
 |      
 |      Examples
 |      --------
 |      >>> import numpy as np
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> v = np.array([1, 0, -1])
 |      >>> A.dot(v)
 |      array([ 1, -3, -1], dtype=int64)
 |  
 |  getH(self)
 |      Return the Hermitian transpose of this matrix.
 |      
 |      See Also
 |      --------
 |      np.matrix.getH : NumPy's implementation of `getH` for matrices
 |  
 |  get_shape(self)
 |      Get shape of a matrix.
 |  
 |  getcol(self, j)
 |      Returns a copy of column j of the matrix, as an (m x 1) sparse
 |      matrix (column vector).
 |  
 |  getformat(self)
 |      Format of a matrix representation as a string.
 |  
 |  getmaxprint(self)
 |      Maximum number of elements to display when printed.
 |  
 |  getrow(self, i)
 |      Returns a copy of row i of the matrix, as a (1 x n) sparse
 |      matrix (row vector).
 |  
 |  maximum(self, other)
 |      Element-wise maximum between this and another matrix.
 |  
 |  mean(self, axis=None, dtype=None, out=None)
 |      Compute the arithmetic mean along the specified axis.
 |      
 |      Returns the average of the matrix elements. The average is taken
 |      over all elements in the matrix by default, otherwise over the
 |      specified axis. `float64` intermediate and return values are used
 |      for integer inputs.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the mean is computed. The default is to compute
 |          the mean of all elements in the matrix (i.e. `axis` = `None`).
 |      dtype : data-type, optional
 |          Type to use in computing the mean. For integer inputs, the default
 |          is `float64`; for floating point inputs, it is the same as the
 |          input dtype.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      m : np.matrix
 |      
 |      See Also
 |      --------
 |      np.matrix.mean : NumPy's implementation of 'mean' for matrices
 |  
 |  minimum(self, other)
 |      Element-wise minimum between this and another matrix.
 |  
 |  multiply(self, other)
 |      Point-wise multiplication by another matrix
 |  
 |  nonzero(self)
 |      nonzero indices
 |      
 |      Returns a tuple of arrays (row,col) containing the indices
 |      of the non-zero elements of the matrix.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1,2,0],[0,0,3],[4,0,5]])
 |      >>> A.nonzero()
 |      (array([0, 0, 1, 2, 2]), array([0, 1, 2, 0, 2]))
 |  
 |  set_shape(self, shape)
 |      See `reshape`.
 |  
 |  setdiag(self, values, k=0)
 |      Set diagonal or off-diagonal elements of the array.
 |      
 |      Parameters
 |      ----------
 |      values : array_like
 |          New values of the diagonal elements.
 |      
 |          Values may have any length.  If the diagonal is longer than values,
 |          then the remaining diagonal entries will not be set.  If values if
 |          longer than the diagonal, then the remaining values are ignored.
 |      
 |          If a scalar value is given, all of the diagonal is set to it.
 |      
 |      k : int, optional
 |          Which off-diagonal to set, corresponding to elements a[i,i+k].
 |          Default: 0 (the main diagonal).
 |  
 |  sum(self, axis=None, dtype=None, out=None)
 |      Sum the matrix elements over a given axis.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the sum of all the matrix elements, returning a scalar
 |          (i.e. `axis` = `None`).
 |      dtype : dtype, optional
 |          The type of the returned matrix and of the accumulator in which
 |          the elements are summed.  The dtype of `a` is used by default
 |          unless `a` has an integer dtype of less precision than the default
 |          platform integer.  In that case, if `a` is signed then the platform
 |          integer is used while if `a` is unsigned then an unsigned integer
 |          of the same precision as the platform integer is used.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      sum_along_axis : np.matrix
 |          A matrix with the same shape as `self`, with the specified
 |          axis removed.
 |      
 |      See Also
 |      --------
 |      np.matrix.sum : NumPy's implementation of 'sum' for matrices
 |  
 |  tobsr(self, blocksize=None, copy=False)
 |      Convert this matrix to Block Sparse Row format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant bsr_matrix.
 |      
 |      When blocksize=(R, C) is provided, it will be used for construction of
 |      the bsr_matrix.
 |  
 |  todense(self, order=None, out=None)
 |      Return a dense matrix representation of this matrix.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F'}, optional
 |          Whether to store multi-dimensional data in C (row-major)
 |          or Fortran (column-major) order in memory. The default
 |          is 'None', indicating the NumPy default of C-ordered.
 |          Cannot be specified in conjunction with the `out`
 |          argument.
 |      
 |      out : ndarray, 2-dimensional, optional
 |          If specified, uses this array (or `numpy.matrix`) as the
 |          output buffer instead of allocating a new array to
 |          return. The provided array must have the same shape and
 |          dtype as the sparse matrix on which you are calling the
 |          method.
 |      
 |      Returns
 |      -------
 |      arr : numpy.matrix, 2-dimensional
 |          A NumPy matrix object with the same shape and containing
 |          the same data represented by the sparse matrix, with the
 |          requested memory order. If `out` was passed and was an
 |          array (rather than a `numpy.matrix`), it will be filled
 |          with the appropriate values and returned wrapped in a
 |          `numpy.matrix` object that shares the same memory.
 |  
 |  tolil(self, copy=False)
 |      Convert this matrix to LInked List format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant lil_matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.base.spmatrix:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  nnz
 |      Number of stored values, including explicit zeros.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  shape
 |      Get shape of a matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.sparse.base.spmatrix:
 |  
 |  __array_priority__ = 10.1
 |  
 |  __hash__ = None
 |  
 |  ndim = 2
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._minmax_mixin:
 |  
 |  argmax(self, axis=None, out=None)
 |      Return indices of maximum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several maximum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmax is computed. If None (default), index
 |          of the maximum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      ind : np.matrix or int
 |          Indices of maximum elements. If matrix, its size along `axis` is 1.
 |  
 |  argmin(self, axis=None, out=None)
 |      Return indices of minimum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several minimum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmin is computed. If None (default), index
 |          of the minimum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |       ind : np.matrix or int
 |          Indices of minimum elements. If matrix, its size along `axis` is 1.
 |  
 |  max(self, axis=None, out=None)
 |      Return the maximum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the maximum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amax : coo_matrix or scalar
 |          Maximum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      min : The minimum value of a sparse matrix along a given axis.
 |      np.matrix.max : NumPy's implementation of 'max' for matrices
 |  
 |  min(self, axis=None, out=None)
 |      Return the minimum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the minimum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amin : coo_matrix or scalar
 |          Minimum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      max : The maximum value of a sparse matrix along a given axis.
 |      np.matrix.min : NumPy's implementation of 'min' for matrices
",class,"('self', 'arg1', 'shape', 'dtype', 'copy')","(nan, nan, None, None, False)","(nan, nan, 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, arg1, shape=None, dtype=None, copy=False)',)"
scipy,1.1.0,scipy.integrate._ivp.common.find,integrate._ivp.common,find,"Python Library Documentation: function find in module scipy.sparse.extract

find(A)
    Return the indices and values of the nonzero elements of a matrix
    
    Parameters
    ----------
    A : dense or sparse matrix
        Matrix whose nonzero elements are desired.
    
    Returns
    -------
    (I,J,V) : tuple of arrays
        I,J, and V contain the row indices, column indices, and values
        of the nonzero matrix entries.
    
    
    Examples
    --------
    >>> from scipy.sparse import csr_matrix, find
    >>> A = csr_matrix([[7.0, 8.0, 0],[0, 0, 9.0]])
    >>> find(A)
    (array([0, 0, 1], dtype=int32), array([0, 1, 2], dtype=int32), array([ 7.,  8.,  9.]))
",function,"('(A)',)",scipy,1.1.0,scipy.integrate._ivp.common.find,integrate._ivp.common,find,"Python Library Documentation: function find in module scipy.sparse.extract

find(A)
    Return the indices and values of the nonzero elements of a matrix
    
    Parameters
    ----------
    A : dense or sparse matrix
        Matrix whose nonzero elements are desired.
    
    Returns
    -------
    (I,J,V) : tuple of arrays
        I,J, and V contain the row indices, column indices, and values
        of the nonzero matrix entries.
    
    
    Examples
    --------
    >>> from scipy.sparse import csr_matrix, find
    >>> A = csr_matrix([[7.0, 8.0, 0],[0, 0, 9.0]])
    >>> find(A)
    (array([0, 0, 1], dtype=int32), array([0, 1, 2], dtype=int32), array([ 7.,  8.,  9.]))
",function,"('A',)","(nan,)","(nan,)","('arg_info',)","('(A)',)"
scipy,1.1.0,scipy.integrate._ivp.common.groupby,integrate._ivp.common,groupby,"Python Library Documentation: class groupby in module itertools

class groupby(builtins.object)
 |  groupby(iterable, key=None) -> make an iterator that returns consecutive
 |  keys and groups from the iterable.  If the key function is not specified or
 |  is None, the element itself is used for grouping.
 |  
 |  Methods defined here:
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __next__(self, /)
 |      Implement next(self).
 |  
 |  __reduce__(...)
 |      Return state information for pickling.
 |  
 |  __setstate__(...)
 |      Set state information for unpickling.
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.integrate._ivp.common.groupby,integrate._ivp.common,groupby,"Python Library Documentation: class groupby in module itertools

class groupby(builtins.object)
 |  groupby(iterable, key=None) -> make an iterator that returns consecutive
 |  keys and groups from the iterable.  If the key function is not specified or
 |  is None, the element itself is used for grouping.
 |  
 |  Methods defined here:
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __next__(self, /)
 |      Implement next(self).
 |  
 |  __reduce__(...)
 |      Return state information for pickling.
 |  
 |  __setstate__(...)
 |      Set state information for unpickling.
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.integrate._ivp.common.norm,integrate._ivp.common,norm,"Python Library Documentation: function norm in module scipy.integrate._ivp.common

norm(x)
    Compute RMS norm.
",function,"('(x)',)",scipy,1.1.0,scipy.integrate._ivp.common.norm,integrate._ivp.common,norm,"Python Library Documentation: function norm in module scipy.integrate._ivp.common

norm(x)
    Compute RMS norm.
",function,"('x',)","(nan,)","(nan,)","('arg_info',)","('(x)',)"
scipy,1.1.0,scipy.integrate._ivp.common.num_jac,integrate._ivp.common,num_jac,"Python Library Documentation: function num_jac in module scipy.integrate._ivp.common

num_jac(fun, t, y, f, threshold, factor, sparsity=None)
    Finite differences Jacobian approximation tailored for ODE solvers.
    
    This function computes finite difference approximation to the Jacobian
    matrix of `fun` with respect to `y` using forward differences.
    The Jacobian matrix has shape (n, n) and its element (i, j) is equal to
    ``d f_i / d y_j``.
    
    A special feature of this function is the ability to correct the step
    size from iteration to iteration. The main idea is to keep the finite
    difference significantly separated from its round-off error which
    approximately equals ``EPS * np.abs(f)``. It reduces a possibility of a
    huge error and assures that the estimated derivative are reasonably close
    to the true values (i.e. the finite difference approximation is at least
    qualitatively reflects the structure of the true Jacobian).
    
    Parameters
    ----------
    fun : callable
        Right-hand side of the system implemented in a vectorized fashion.
    t : float
        Current time.
    y : ndarray, shape (n,)
        Current state.
    f : ndarray, shape (n,)
        Value of the right hand side at (t, y).
    threshold : float
        Threshold for `y` value used for computing the step size as
        ``factor * np.maximum(np.abs(y), threshold)``. Typically the value of
        absolute tolerance (atol) for a solver should be passed as `threshold`.
    factor : ndarray with shape (n,) or None
        Factor to use for computing the step size. Pass None for the very
        evaluation, then use the value returned from this function.
    sparsity : tuple (structure, groups) or None
        Sparsity structure of the Jacobian, `structure` must be csc_matrix.
    
    Returns
    -------
    J : ndarray or csc_matrix, shape (n, n)
        Jacobian matrix.
    factor : ndarray, shape (n,)
        Suggested `factor` for the next evaluation.
",function,"('(fun, t, y, f, threshold, factor, sparsity=None)',)",scipy,1.1.0,scipy.integrate._ivp.common.num_jac,integrate._ivp.common,num_jac,"Python Library Documentation: function num_jac in module scipy.integrate._ivp.common

num_jac(fun, t, y, f, threshold, factor, sparsity=None)
    Finite differences Jacobian approximation tailored for ODE solvers.
    
    This function computes finite difference approximation to the Jacobian
    matrix of `fun` with respect to `y` using forward differences.
    The Jacobian matrix has shape (n, n) and its element (i, j) is equal to
    ``d f_i / d y_j``.
    
    A special feature of this function is the ability to correct the step
    size from iteration to iteration. The main idea is to keep the finite
    difference significantly separated from its round-off error which
    approximately equals ``EPS * np.abs(f)``. It reduces a possibility of a
    huge error and assures that the estimated derivative are reasonably close
    to the true values (i.e. the finite difference approximation is at least
    qualitatively reflects the structure of the true Jacobian).
    
    Parameters
    ----------
    fun : callable
        Right-hand side of the system implemented in a vectorized fashion.
    t : float
        Current time.
    y : ndarray, shape (n,)
        Current state.
    f : ndarray, shape (n,)
        Value of the right hand side at (t, y).
    threshold : float
        Threshold for `y` value used for computing the step size as
        ``factor * np.maximum(np.abs(y), threshold)``. Typically the value of
        absolute tolerance (atol) for a solver should be passed as `threshold`.
    factor : ndarray with shape (n,) or None
        Factor to use for computing the step size. Pass None for the very
        evaluation, then use the value returned from this function.
    sparsity : tuple (structure, groups) or None
        Sparsity structure of the Jacobian, `structure` must be csc_matrix.
    
    Returns
    -------
    J : ndarray or csc_matrix, shape (n, n)
        Jacobian matrix.
    factor : ndarray, shape (n,)
        Suggested `factor` for the next evaluation.
",function,"('fun', 't', 'y', 'f', 'threshold', 'factor', 'sparsity')","(nan, nan, nan, nan, nan, nan, None)","(nan, nan, nan, nan, nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(fun, t, y, f, threshold, factor, sparsity=None)',)"
scipy,1.1.0,scipy.integrate._ivp.common.select_initial_step,integrate._ivp.common,select_initial_step,"Python Library Documentation: function select_initial_step in module scipy.integrate._ivp.common

select_initial_step(fun, t0, y0, f0, direction, order, rtol, atol)
    Empirically select a good initial step.
    
    The algorithm is described in [1]_.
    
    Parameters
    ----------
    fun : callable
        Right-hand side of the system.
    t0 : float
        Initial value of the independent variable.
    y0 : ndarray, shape (n,)
        Initial value of the dependent variable.
    f0 : ndarray, shape (n,)
        Initial value of the derivative, i. e. ``fun(t0, y0)``.
    direction : float
        Integration direction.
    order : float
        Method order.
    rtol : float
        Desired relative tolerance.
    atol : float
        Desired absolute tolerance.
    
    Returns
    -------
    h_abs : float
        Absolute value of the suggested initial step.
    
    References
    ----------
    .. [1] E. Hairer, S. P. Norsett G. Wanner, ""Solving Ordinary Differential
           Equations I: Nonstiff Problems"", Sec. II.4.
",function,"('(fun, t0, y0, f0, direction, order, rtol, atol)',)",scipy,1.1.0,scipy.integrate._ivp.common.select_initial_step,integrate._ivp.common,select_initial_step,"Python Library Documentation: function select_initial_step in module scipy.integrate._ivp.common

select_initial_step(fun, t0, y0, f0, direction, order, rtol, atol)
    Empirically select a good initial step.
    
    The algorithm is described in [1]_.
    
    Parameters
    ----------
    fun : callable
        Right-hand side of the system.
    t0 : float
        Initial value of the independent variable.
    y0 : ndarray, shape (n,)
        Initial value of the dependent variable.
    f0 : ndarray, shape (n,)
        Initial value of the derivative, i. e. ``fun(t0, y0)``.
    direction : float
        Integration direction.
    order : float
        Method order.
    rtol : float
        Desired relative tolerance.
    atol : float
        Desired absolute tolerance.
    
    Returns
    -------
    h_abs : float
        Absolute value of the suggested initial step.
    
    References
    ----------
    .. [1] E. Hairer, S. P. Norsett G. Wanner, ""Solving Ordinary Differential
           Equations I: Nonstiff Problems"", Sec. II.4.
",function,"('fun', 't0', 'y0', 'f0', 'direction', 'order', 'rtol', 'atol')","(nan, nan, nan, nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(fun, t0, y0, f0, direction, order, rtol, atol)',)"
scipy,1.1.0,scipy.integrate._ivp.common.validate_max_step,integrate._ivp.common,validate_max_step,"Python Library Documentation: function validate_max_step in module scipy.integrate._ivp.common

validate_max_step(max_step)
    Assert that max_Step is valid and return it.
",function,"('(max_step)',)",scipy,1.1.0,scipy.integrate._ivp.common.validate_max_step,integrate._ivp.common,validate_max_step,"Python Library Documentation: function validate_max_step in module scipy.integrate._ivp.common

validate_max_step(max_step)
    Assert that max_Step is valid and return it.
",function,"('max_step',)","(nan,)","(nan,)","('arg_info',)","('(max_step)',)"
scipy,1.1.0,scipy.integrate._ivp.common.validate_tol,integrate._ivp.common,validate_tol,"Python Library Documentation: function validate_tol in module scipy.integrate._ivp.common

validate_tol(rtol, atol, n)
    Validate tolerance values.
",function,"('(rtol, atol, n)',)",scipy,1.1.0,scipy.integrate._ivp.common.validate_tol,integrate._ivp.common,validate_tol,"Python Library Documentation: function validate_tol in module scipy.integrate._ivp.common

validate_tol(rtol, atol, n)
    Validate tolerance values.
",function,"('rtol', 'atol', 'n')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(rtol, atol, n)',)"
scipy,1.1.0,scipy.integrate._ivp.common.warn_extraneous,integrate._ivp.common,warn_extraneous,"Python Library Documentation: function warn_extraneous in module scipy.integrate._ivp.common

warn_extraneous(extraneous)
    Display a warning for extraneous keyword arguments.
    
    The initializer of each solver class is expected to collect keyword
    arguments that it doesn't understand and warn about them. This function
    prints a warning for each key in the supplied dictionary.
    
    Parameters
    ----------
    extraneous : dict
        Extraneous keyword arguments
",function,"('(extraneous)',)",scipy,1.1.0,scipy.integrate._ivp.common.warn_extraneous,integrate._ivp.common,warn_extraneous,"Python Library Documentation: function warn_extraneous in module scipy.integrate._ivp.common

warn_extraneous(extraneous)
    Display a warning for extraneous keyword arguments.
    
    The initializer of each solver class is expected to collect keyword
    arguments that it doesn't understand and warn about them. This function
    prints a warning for each key in the supplied dictionary.
    
    Parameters
    ----------
    extraneous : dict
        Extraneous keyword arguments
",function,"('extraneous',)","(nan,)","(nan,)","('arg_info',)","('(extraneous)',)"
scipy,1.1.0,scipy.integrate._ivp.ivp.BDF,integrate._ivp.ivp,BDF,"Python Library Documentation: class BDF in module scipy.integrate._ivp.bdf

class BDF(scipy.integrate._ivp.base.OdeSolver)
 |  Implicit method based on backward-differentiation formulas.
 |  
 |  This is a variable order method with the order varying automatically from
 |  1 to 5. The general framework of the BDF algorithm is described in [1]_.
 |  This class implements a quasi-constant step size as explained in [2]_.
 |  The error estimation strategy for the constant-step BDF is derived in [3]_.
 |  An accuracy enhancement using modified formulas (NDF) [2]_ is also implemented.
 |  
 |  Can be applied in the complex domain.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar, and there are two options for the ndarray ``y``:
 |      It can either have shape (n,); then ``fun`` must return array_like with
 |      shape (n,). Alternatively it can have shape (n, k); then ``fun``
 |      must return an array_like with shape (n, k), i.e. each column
 |      corresponds to a single column in ``y``. The choice between the two
 |      options is determined by `vectorized` argument (see below). The
 |      vectorized implementation allows a faster approximation of the Jacobian
 |      by finite differences (required for this solver).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time - the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  max_step : float, optional
 |      Maximum allowed step size. Default is np.inf, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  rtol, atol : float and array_like, optional
 |      Relative and absolute tolerances. The solver keeps the local error
 |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
 |      relative accuracy (number of correct digits). But if a component of `y`
 |      is approximately below `atol`, the error only needs to fall within
 |      the same `atol` threshold, and the number of correct digits is not
 |      guaranteed. If components of y have different scales, it might be
 |      beneficial to set different `atol` values for different components by
 |      passing array_like with shape (n,) for `atol`. Default values are
 |      1e-3 for `rtol` and 1e-6 for `atol`.
 |  jac : {None, array_like, sparse_matrix, callable}, optional
 |      Jacobian matrix of the right-hand side of the system with respect to y,
 |      required by this method. The Jacobian matrix has shape (n, n) and its
 |      element (i, j) is equal to ``d f_i / d y_j``.
 |      There are three ways to define the Jacobian:
 |  
 |          * If array_like or sparse_matrix, the Jacobian is assumed to
 |            be constant.
 |          * If callable, the Jacobian is assumed to depend on both
 |            t and y; it will be called as ``jac(t, y)`` as necessary.
 |            For the 'Radau' and 'BDF' methods, the return value might be a
 |            sparse matrix.
 |          * If None (default), the Jacobian will be approximated by
 |            finite differences.
 |  
 |      It is generally recommended to provide the Jacobian rather than
 |      relying on a finite-difference approximation.
 |  jac_sparsity : {None, array_like, sparse matrix}, optional
 |      Defines a sparsity structure of the Jacobian matrix for a
 |      finite-difference approximation. Its shape must be (n, n). This argument
 |      is ignored if `jac` is not `None`. If the Jacobian has only few non-zero
 |      elements in *each* row, providing the sparsity structure will greatly
 |      speed up the computations [4]_. A zero entry means that a corresponding
 |      element in the Jacobian is always zero. If None (default), the Jacobian
 |      is assumed to be dense.
 |  vectorized : bool, optional
 |      Whether `fun` is implemented in a vectorized fashion. Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number of evaluations of the right-hand side.
 |  njev : int
 |      Number of evaluations of the Jacobian.
 |  nlu : int
 |      Number of LU decompositions.
 |  
 |  References
 |  ----------
 |  .. [1] G. D. Byrne, A. C. Hindmarsh, ""A Polyalgorithm for the Numerical
 |         Solution of Ordinary Differential Equations"", ACM Transactions on
 |         Mathematical Software, Vol. 1, No. 1, pp. 71-96, March 1975.
 |  .. [2] L. F. Shampine, M. W. Reichelt, ""THE MATLAB ODE SUITE"", SIAM J. SCI.
 |         COMPUTE., Vol. 18, No. 1, pp. 1-22, January 1997.
 |  .. [3] E. Hairer, G. Wanner, ""Solving Ordinary Differential Equations I:
 |         Nonstiff Problems"", Sec. III.2.
 |  .. [4] A. Curtis, M. J. D. Powell, and J. Reid, ""On the estimation of
 |         sparse Jacobian matrices"", Journal of the Institute of Mathematics
 |         and its Applications, 13, pp. 117-120, 1974.
 |  
 |  Method resolution order:
 |      BDF
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, jac=None, jac_sparsity=None, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, jac=None, jac_sparsity=None, vectorized=False, **extraneous)',)",scipy,1.1.0,scipy.integrate._ivp.ivp.BDF,integrate._ivp.ivp,BDF,"Python Library Documentation: class BDF in module scipy.integrate._ivp.bdf

class BDF(scipy.integrate._ivp.base.OdeSolver)
 |  Implicit method based on backward-differentiation formulas.
 |  
 |  This is a variable order method with the order varying automatically from
 |  1 to 5. The general framework of the BDF algorithm is described in [1]_.
 |  This class implements a quasi-constant step size as explained in [2]_.
 |  The error estimation strategy for the constant-step BDF is derived in [3]_.
 |  An accuracy enhancement using modified formulas (NDF) [2]_ is also implemented.
 |  
 |  Can be applied in the complex domain.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar, and there are two options for the ndarray ``y``:
 |      It can either have shape (n,); then ``fun`` must return array_like with
 |      shape (n,). Alternatively it can have shape (n, k); then ``fun``
 |      must return an array_like with shape (n, k), i.e. each column
 |      corresponds to a single column in ``y``. The choice between the two
 |      options is determined by `vectorized` argument (see below). The
 |      vectorized implementation allows a faster approximation of the Jacobian
 |      by finite differences (required for this solver).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time - the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  max_step : float, optional
 |      Maximum allowed step size. Default is np.inf, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  rtol, atol : float and array_like, optional
 |      Relative and absolute tolerances. The solver keeps the local error
 |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
 |      relative accuracy (number of correct digits). But if a component of `y`
 |      is approximately below `atol`, the error only needs to fall within
 |      the same `atol` threshold, and the number of correct digits is not
 |      guaranteed. If components of y have different scales, it might be
 |      beneficial to set different `atol` values for different components by
 |      passing array_like with shape (n,) for `atol`. Default values are
 |      1e-3 for `rtol` and 1e-6 for `atol`.
 |  jac : {None, array_like, sparse_matrix, callable}, optional
 |      Jacobian matrix of the right-hand side of the system with respect to y,
 |      required by this method. The Jacobian matrix has shape (n, n) and its
 |      element (i, j) is equal to ``d f_i / d y_j``.
 |      There are three ways to define the Jacobian:
 |  
 |          * If array_like or sparse_matrix, the Jacobian is assumed to
 |            be constant.
 |          * If callable, the Jacobian is assumed to depend on both
 |            t and y; it will be called as ``jac(t, y)`` as necessary.
 |            For the 'Radau' and 'BDF' methods, the return value might be a
 |            sparse matrix.
 |          * If None (default), the Jacobian will be approximated by
 |            finite differences.
 |  
 |      It is generally recommended to provide the Jacobian rather than
 |      relying on a finite-difference approximation.
 |  jac_sparsity : {None, array_like, sparse matrix}, optional
 |      Defines a sparsity structure of the Jacobian matrix for a
 |      finite-difference approximation. Its shape must be (n, n). This argument
 |      is ignored if `jac` is not `None`. If the Jacobian has only few non-zero
 |      elements in *each* row, providing the sparsity structure will greatly
 |      speed up the computations [4]_. A zero entry means that a corresponding
 |      element in the Jacobian is always zero. If None (default), the Jacobian
 |      is assumed to be dense.
 |  vectorized : bool, optional
 |      Whether `fun` is implemented in a vectorized fashion. Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number of evaluations of the right-hand side.
 |  njev : int
 |      Number of evaluations of the Jacobian.
 |  nlu : int
 |      Number of LU decompositions.
 |  
 |  References
 |  ----------
 |  .. [1] G. D. Byrne, A. C. Hindmarsh, ""A Polyalgorithm for the Numerical
 |         Solution of Ordinary Differential Equations"", ACM Transactions on
 |         Mathematical Software, Vol. 1, No. 1, pp. 71-96, March 1975.
 |  .. [2] L. F. Shampine, M. W. Reichelt, ""THE MATLAB ODE SUITE"", SIAM J. SCI.
 |         COMPUTE., Vol. 18, No. 1, pp. 1-22, January 1997.
 |  .. [3] E. Hairer, G. Wanner, ""Solving Ordinary Differential Equations I:
 |         Nonstiff Problems"", Sec. III.2.
 |  .. [4] A. Curtis, M. J. D. Powell, and J. Reid, ""On the estimation of
 |         sparse Jacobian matrices"", Journal of the Institute of Mathematics
 |         and its Applications, 13, pp. 117-120, 1974.
 |  
 |  Method resolution order:
 |      BDF
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, jac=None, jac_sparsity=None, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('self', 'fun', 't0', 'y0', 't_bound', 'max_step', 'rtol', 'atol', 'jac', 'jac_sparsity', 'vectorized')","(nan, nan, nan, nan, nan, inf, 0.001, 1e-06, None, None, False)","(nan, nan, nan, nan, nan, 'float', 'float', 'float', 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, jac=None, jac_sparsity=None, vectorized=False, **extraneous)',)"
scipy,1.1.0,scipy.integrate._ivp.ivp.LSODA,integrate._ivp.ivp,LSODA,"Python Library Documentation: class LSODA in module scipy.integrate._ivp.lsoda

class LSODA(scipy.integrate._ivp.base.OdeSolver)
 |  Adams/BDF method with automatic stiffness detection and switching.
 |  
 |  This is a wrapper to the Fortran solver from ODEPACK [1]_. It switches
 |  automatically between the nonstiff Adams method and the stiff BDF method.
 |  The method was originally detailed in [2]_.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar, and there are two options for the ndarray ``y``:
 |      It can either have shape (n,); then ``fun`` must return array_like with
 |      shape (n,). Alternatively it can have shape (n, k); then ``fun``
 |      must return an array_like with shape (n, k), i.e. each column
 |      corresponds to a single column in ``y``. The choice between the two
 |      options is determined by `vectorized` argument (see below). The
 |      vectorized implementation allows a faster approximation of the Jacobian
 |      by finite differences (required for this solver).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time - the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  first_step : float or None, optional
 |      Initial step size. Default is ``None`` which means that the algorithm
 |      should choose.
 |  min_step : float, optional
 |      Minimum allowed step size. Default is 0.0, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  max_step : float, optional
 |      Maximum allowed step size. Default is np.inf, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  rtol, atol : float and array_like, optional
 |      Relative and absolute tolerances. The solver keeps the local error
 |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
 |      relative accuracy (number of correct digits). But if a component of `y`
 |      is approximately below `atol`, the error only needs to fall within
 |      the same `atol` threshold, and the number of correct digits is not
 |      guaranteed. If components of y have different scales, it might be
 |      beneficial to set different `atol` values for different components by
 |      passing array_like with shape (n,) for `atol`. Default values are
 |      1e-3 for `rtol` and 1e-6 for `atol`.
 |  jac : None or callable, optional
 |      Jacobian matrix of the right-hand side of the system with respect to
 |      ``y``. The Jacobian matrix has shape (n, n) and its element (i, j) is
 |      equal to ``d f_i / d y_j``. The function will be called as
 |      ``jac(t, y)``. If None (default), the Jacobian will be
 |      approximated by finite differences. It is generally recommended to
 |      provide the Jacobian rather than relying on a finite-difference
 |      approximation.
 |  lband, uband : int or None
 |      Parameters defining the bandwidth of the Jacobian,
 |      i.e., ``jac[i, j] != 0 only for i - lband <= j <= i + uband``. Setting
 |      these requires your jac routine to return the Jacobian in the packed format:
 |      the returned array must have ``n`` columns and ``uband + lband + 1``
 |      rows in which Jacobian diagonals are written. Specifically
 |      ``jac_packed[uband + i - j , j] = jac[i, j]``. The same format is used
 |      in `scipy.linalg.solve_banded` (check for an illustration).
 |      These parameters can be also used with ``jac=None`` to reduce the
 |      number of Jacobian elements estimated by finite differences.
 |  vectorized : bool, optional
 |      Whether `fun` is implemented in a vectorized fashion. A vectorized
 |      implementation offers no advantages for this solver. Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  nfev : int
 |      Number of evaluations of the right-hand side.
 |  njev : int
 |      Number of evaluations of the Jacobian.
 |  
 |  References
 |  ----------
 |  .. [1] A. C. Hindmarsh, ""ODEPACK, A Systematized Collection of ODE
 |         Solvers,"" IMACS Transactions on Scientific Computation, Vol 1.,
 |         pp. 55-64, 1983.
 |  .. [2] L. Petzold, ""Automatic selection of methods for solving stiff and
 |         nonstiff systems of ordinary differential equations"", SIAM Journal
 |         on Scientific and Statistical Computing, Vol. 4, No. 1, pp. 136-148,
 |         1983.
 |  
 |  Method resolution order:
 |      LSODA
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, first_step=None, min_step=0.0, max_step=inf, rtol=0.001, atol=1e-06, jac=None, lband=None, uband=None, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('(self, fun, t0, y0, t_bound, first_step=None, min_step=0.0, max_step=inf, rtol=0.001, atol=1e-06, jac=None, lband=None, uband=None, vectorized=False, **extraneous)',)",scipy,1.1.0,scipy.integrate._ivp.ivp.LSODA,integrate._ivp.ivp,LSODA,"Python Library Documentation: class LSODA in module scipy.integrate._ivp.lsoda

class LSODA(scipy.integrate._ivp.base.OdeSolver)
 |  Adams/BDF method with automatic stiffness detection and switching.
 |  
 |  This is a wrapper to the Fortran solver from ODEPACK [1]_. It switches
 |  automatically between the nonstiff Adams method and the stiff BDF method.
 |  The method was originally detailed in [2]_.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar, and there are two options for the ndarray ``y``:
 |      It can either have shape (n,); then ``fun`` must return array_like with
 |      shape (n,). Alternatively it can have shape (n, k); then ``fun``
 |      must return an array_like with shape (n, k), i.e. each column
 |      corresponds to a single column in ``y``. The choice between the two
 |      options is determined by `vectorized` argument (see below). The
 |      vectorized implementation allows a faster approximation of the Jacobian
 |      by finite differences (required for this solver).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time - the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  first_step : float or None, optional
 |      Initial step size. Default is ``None`` which means that the algorithm
 |      should choose.
 |  min_step : float, optional
 |      Minimum allowed step size. Default is 0.0, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  max_step : float, optional
 |      Maximum allowed step size. Default is np.inf, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  rtol, atol : float and array_like, optional
 |      Relative and absolute tolerances. The solver keeps the local error
 |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
 |      relative accuracy (number of correct digits). But if a component of `y`
 |      is approximately below `atol`, the error only needs to fall within
 |      the same `atol` threshold, and the number of correct digits is not
 |      guaranteed. If components of y have different scales, it might be
 |      beneficial to set different `atol` values for different components by
 |      passing array_like with shape (n,) for `atol`. Default values are
 |      1e-3 for `rtol` and 1e-6 for `atol`.
 |  jac : None or callable, optional
 |      Jacobian matrix of the right-hand side of the system with respect to
 |      ``y``. The Jacobian matrix has shape (n, n) and its element (i, j) is
 |      equal to ``d f_i / d y_j``. The function will be called as
 |      ``jac(t, y)``. If None (default), the Jacobian will be
 |      approximated by finite differences. It is generally recommended to
 |      provide the Jacobian rather than relying on a finite-difference
 |      approximation.
 |  lband, uband : int or None
 |      Parameters defining the bandwidth of the Jacobian,
 |      i.e., ``jac[i, j] != 0 only for i - lband <= j <= i + uband``. Setting
 |      these requires your jac routine to return the Jacobian in the packed format:
 |      the returned array must have ``n`` columns and ``uband + lband + 1``
 |      rows in which Jacobian diagonals are written. Specifically
 |      ``jac_packed[uband + i - j , j] = jac[i, j]``. The same format is used
 |      in `scipy.linalg.solve_banded` (check for an illustration).
 |      These parameters can be also used with ``jac=None`` to reduce the
 |      number of Jacobian elements estimated by finite differences.
 |  vectorized : bool, optional
 |      Whether `fun` is implemented in a vectorized fashion. A vectorized
 |      implementation offers no advantages for this solver. Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  nfev : int
 |      Number of evaluations of the right-hand side.
 |  njev : int
 |      Number of evaluations of the Jacobian.
 |  
 |  References
 |  ----------
 |  .. [1] A. C. Hindmarsh, ""ODEPACK, A Systematized Collection of ODE
 |         Solvers,"" IMACS Transactions on Scientific Computation, Vol 1.,
 |         pp. 55-64, 1983.
 |  .. [2] L. Petzold, ""Automatic selection of methods for solving stiff and
 |         nonstiff systems of ordinary differential equations"", SIAM Journal
 |         on Scientific and Statistical Computing, Vol. 4, No. 1, pp. 136-148,
 |         1983.
 |  
 |  Method resolution order:
 |      LSODA
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, first_step=None, min_step=0.0, max_step=inf, rtol=0.001, atol=1e-06, jac=None, lband=None, uband=None, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('self', 'fun', 't0', 'y0', 't_bound', 'first_step', 'min_step', 'max_step', 'rtol', 'atol', 'jac', 'lband', 'uband', 'vectorized')","(nan, nan, nan, nan, nan, None, 0.0, inf, 0.001, 1e-06, None, None, None, False)","(nan, nan, nan, nan, nan, 'NoneType', 'float', 'float', 'float', 'float', 'NoneType', 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, fun, t0, y0, t_bound, first_step=None, min_step=0.0, max_step=inf, rtol=0.001, atol=1e-06, jac=None, lband=None, uband=None, vectorized=False, **extraneous)',)"
scipy,1.1.0,scipy.integrate._ivp.ivp.OdeResult,integrate._ivp.ivp,OdeResult,"Python Library Documentation: class OdeResult in module scipy.integrate._ivp.ivp

class OdeResult(scipy.optimize.optimize.OptimizeResult)
 |  Represents the optimization result.
 |  
 |  Attributes
 |  ----------
 |  x : ndarray
 |      The solution of the optimization.
 |  success : bool
 |      Whether or not the optimizer exited successfully.
 |  status : int
 |      Termination status of the optimizer. Its value depends on the
 |      underlying solver. Refer to `message` for details.
 |  message : str
 |      Description of the cause of the termination.
 |  fun, jac, hess: ndarray
 |      Values of objective function, its Jacobian and its Hessian (if
 |      available). The Hessians may be approximations, see the documentation
 |      of the function in question.
 |  hess_inv : object
 |      Inverse of the objective function's Hessian; may be an approximation.
 |      Not available for all solvers. The type of this attribute may be
 |      either np.ndarray or scipy.sparse.linalg.LinearOperator.
 |  nfev, njev, nhev : int
 |      Number of evaluations of the objective functions and of its
 |      Jacobian and Hessian.
 |  nit : int
 |      Number of iterations performed by the optimizer.
 |  maxcv : float
 |      The maximum constraint violation.
 |  
 |  Notes
 |  -----
 |  There may be additional attributes not listed above depending of the
 |  specific solver. Since this class is essentially a subclass of dict
 |  with attribute accessors, one can see which attributes are available
 |  using the `keys()` method.
 |  
 |  Method resolution order:
 |      OdeResult
 |      scipy.optimize.optimize.OptimizeResult
 |      builtins.dict
 |      builtins.object
 |  
 |  Methods inherited from scipy.optimize.optimize.OptimizeResult:
 |  
 |  __delattr__ = __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __dir__(self)
 |      __dir__() -> list
 |      default dir() implementation
 |  
 |  __getattr__(self, name)
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __setattr__ = __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.optimize.optimize.OptimizeResult:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.dict:
 |  
 |  __contains__(self, key, /)
 |      True if D has a key k, else False.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __sizeof__(...)
 |      D.__sizeof__() -> size of D in memory, in bytes
 |  
 |  clear(...)
 |      D.clear() -> None.  Remove all items from D.
 |  
 |  copy(...)
 |      D.copy() -> a shallow copy of D
 |  
 |  fromkeys(iterable, value=None, /) from builtins.type
 |      Returns a new dict with keys from iterable and values equal to value.
 |  
 |  get(...)
 |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
 |  
 |  items(...)
 |      D.items() -> a set-like object providing a view on D's items
 |  
 |  keys(...)
 |      D.keys() -> a set-like object providing a view on D's keys
 |  
 |  pop(...)
 |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
 |      If key is not found, d is returned if given, otherwise KeyError is raised
 |  
 |  popitem(...)
 |      D.popitem() -> (k, v), remove and return some (key, value) pair as a
 |      2-tuple; but raise KeyError if D is empty.
 |  
 |  setdefault(...)
 |      D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
 |  
 |  update(...)
 |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
 |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
 |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
 |      In either case, this is followed by: for k in F:  D[k] = F[k]
 |  
 |  values(...)
 |      D.values() -> an object providing a view on D's values
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from builtins.dict:
 |  
 |  __hash__ = None
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.integrate._ivp.ivp.OdeResult,integrate._ivp.ivp,OdeResult,"Python Library Documentation: class OdeResult in module scipy.integrate._ivp.ivp

class OdeResult(scipy.optimize.optimize.OptimizeResult)
 |  Represents the optimization result.
 |  
 |  Attributes
 |  ----------
 |  x : ndarray
 |      The solution of the optimization.
 |  success : bool
 |      Whether or not the optimizer exited successfully.
 |  status : int
 |      Termination status of the optimizer. Its value depends on the
 |      underlying solver. Refer to `message` for details.
 |  message : str
 |      Description of the cause of the termination.
 |  fun, jac, hess: ndarray
 |      Values of objective function, its Jacobian and its Hessian (if
 |      available). The Hessians may be approximations, see the documentation
 |      of the function in question.
 |  hess_inv : object
 |      Inverse of the objective function's Hessian; may be an approximation.
 |      Not available for all solvers. The type of this attribute may be
 |      either np.ndarray or scipy.sparse.linalg.LinearOperator.
 |  nfev, njev, nhev : int
 |      Number of evaluations of the objective functions and of its
 |      Jacobian and Hessian.
 |  nit : int
 |      Number of iterations performed by the optimizer.
 |  maxcv : float
 |      The maximum constraint violation.
 |  
 |  Notes
 |  -----
 |  There may be additional attributes not listed above depending of the
 |  specific solver. Since this class is essentially a subclass of dict
 |  with attribute accessors, one can see which attributes are available
 |  using the `keys()` method.
 |  
 |  Method resolution order:
 |      OdeResult
 |      scipy.optimize.optimize.OptimizeResult
 |      builtins.dict
 |      builtins.object
 |  
 |  Methods inherited from scipy.optimize.optimize.OptimizeResult:
 |  
 |  __delattr__ = __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __dir__(self)
 |      __dir__() -> list
 |      default dir() implementation
 |  
 |  __getattr__(self, name)
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __setattr__ = __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.optimize.optimize.OptimizeResult:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.dict:
 |  
 |  __contains__(self, key, /)
 |      True if D has a key k, else False.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __sizeof__(...)
 |      D.__sizeof__() -> size of D in memory, in bytes
 |  
 |  clear(...)
 |      D.clear() -> None.  Remove all items from D.
 |  
 |  copy(...)
 |      D.copy() -> a shallow copy of D
 |  
 |  fromkeys(iterable, value=None, /) from builtins.type
 |      Returns a new dict with keys from iterable and values equal to value.
 |  
 |  get(...)
 |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
 |  
 |  items(...)
 |      D.items() -> a set-like object providing a view on D's items
 |  
 |  keys(...)
 |      D.keys() -> a set-like object providing a view on D's keys
 |  
 |  pop(...)
 |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
 |      If key is not found, d is returned if given, otherwise KeyError is raised
 |  
 |  popitem(...)
 |      D.popitem() -> (k, v), remove and return some (key, value) pair as a
 |      2-tuple; but raise KeyError if D is empty.
 |  
 |  setdefault(...)
 |      D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
 |  
 |  update(...)
 |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
 |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
 |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
 |      In either case, this is followed by: for k in F:  D[k] = F[k]
 |  
 |  values(...)
 |      D.values() -> an object providing a view on D's values
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from builtins.dict:
 |  
 |  __hash__ = None
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.integrate._ivp.ivp.OdeSolution,integrate._ivp.ivp,OdeSolution,"Python Library Documentation: class OdeSolution in module scipy.integrate._ivp.common

class OdeSolution(builtins.object)
 |  Continuous ODE solution.
 |  
 |  It is organized as a collection of `DenseOutput` objects which represent
 |  local interpolants. It provides an algorithm to select a right interpolant
 |  for each given point.
 |  
 |  The interpolants cover the range between `t_min` and `t_max` (see
 |  Attributes below). Evaluation outside this interval is not forbidden, but
 |  the accuracy is not guaranteed.
 |  
 |  When evaluating at a breakpoint (one of the values in `ts`) a segment with
 |  the lower index is selected.
 |  
 |  Parameters
 |  ----------
 |  ts : array_like, shape (n_segments + 1,)
 |      Time instants between which local interpolants are defined. Must
 |      be strictly increasing or decreasing (zero segment with two points is
 |      also allowed).
 |  interpolants : list of DenseOutput with n_segments elements
 |      Local interpolants. An i-th interpolant is assumed to be defined
 |      between ``ts[i]`` and ``ts[i + 1]``.
 |  
 |  Attributes
 |  ----------
 |  t_min, t_max : float
 |      Time range of the interpolation.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, t)
 |      Evaluate the solution.
 |      
 |      Parameters
 |      ----------
 |      t : float or array_like with shape (n_points,)
 |          Points to evaluate at.
 |      
 |      Returns
 |      -------
 |      y : ndarray, shape (n_states,) or (n_states, n_points)
 |          Computed values. Shape depends on whether `t` is a scalar or a
 |          1-d array.
 |  
 |  __init__(self, ts, interpolants)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, ts, interpolants)',)",scipy,1.1.0,scipy.integrate._ivp.ivp.OdeSolution,integrate._ivp.ivp,OdeSolution,"Python Library Documentation: class OdeSolution in module scipy.integrate._ivp.common

class OdeSolution(builtins.object)
 |  Continuous ODE solution.
 |  
 |  It is organized as a collection of `DenseOutput` objects which represent
 |  local interpolants. It provides an algorithm to select a right interpolant
 |  for each given point.
 |  
 |  The interpolants cover the range between `t_min` and `t_max` (see
 |  Attributes below). Evaluation outside this interval is not forbidden, but
 |  the accuracy is not guaranteed.
 |  
 |  When evaluating at a breakpoint (one of the values in `ts`) a segment with
 |  the lower index is selected.
 |  
 |  Parameters
 |  ----------
 |  ts : array_like, shape (n_segments + 1,)
 |      Time instants between which local interpolants are defined. Must
 |      be strictly increasing or decreasing (zero segment with two points is
 |      also allowed).
 |  interpolants : list of DenseOutput with n_segments elements
 |      Local interpolants. An i-th interpolant is assumed to be defined
 |      between ``ts[i]`` and ``ts[i + 1]``.
 |  
 |  Attributes
 |  ----------
 |  t_min, t_max : float
 |      Time range of the interpolation.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, t)
 |      Evaluate the solution.
 |      
 |      Parameters
 |      ----------
 |      t : float or array_like with shape (n_points,)
 |          Points to evaluate at.
 |      
 |      Returns
 |      -------
 |      y : ndarray, shape (n_states,) or (n_states, n_points)
 |          Computed values. Shape depends on whether `t` is a scalar or a
 |          1-d array.
 |  
 |  __init__(self, ts, interpolants)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'ts', 'interpolants')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(self, ts, interpolants)',)"
scipy,1.1.0,scipy.integrate._ivp.ivp.OdeSolver,integrate._ivp.ivp,OdeSolver,"Python Library Documentation: class OdeSolver in module scipy.integrate._ivp.base

class OdeSolver(builtins.object)
 |  Base class for ODE solvers.
 |  
 |  In order to implement a new solver you need to follow the guidelines:
 |  
 |      1. A constructor must accept parameters presented in the base class
 |         (listed below) along with any other parameters specific to a solver.
 |      2. A constructor must accept arbitrary extraneous arguments
 |         ``**extraneous``, but warn that these arguments are irrelevant
 |         using `common.warn_extraneous` function. Do not pass these
 |         arguments to the base class.
 |      3. A solver must implement a private method `_step_impl(self)` which
 |         propagates a solver one step further. It must return tuple
 |         ``(success, message)``, where ``success`` is a boolean indicating
 |         whether a step was successful, and ``message`` is a string
 |         containing description of a failure if a step failed or None
 |         otherwise.
 |      4. A solver must implement a private method `_dense_output_impl(self)`
 |         which returns a `DenseOutput` object covering the last successful
 |         step.
 |      5. A solver must have attributes listed below in Attributes section.
 |         Note that `t_old` and `step_size` are updated automatically.
 |      6. Use `fun(self, t, y)` method for the system rhs evaluation, this
 |         way the number of function evaluations (`nfev`) will be tracked
 |         automatically.
 |      7. For convenience a base class provides `fun_single(self, t, y)` and
 |         `fun_vectorized(self, t, y)` for evaluating the rhs in
 |         non-vectorized and vectorized fashions respectively (regardless of
 |         how `fun` from the constructor is implemented). These calls don't
 |         increment `nfev`.
 |      8. If a solver uses a Jacobian matrix and LU decompositions, it should
 |         track the number of Jacobian evaluations (`njev`) and the number of
 |         LU decompositions (`nlu`).
 |      9. By convention the function evaluations used to compute a finite
 |         difference approximation of the Jacobian should not be counted in
 |         `nfev`, thus use `fun_single(self, t, y)` or
 |         `fun_vectorized(self, t, y)` when computing a finite difference
 |         approximation of the Jacobian.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar and there are two options for ndarray ``y``.
 |      It can either have shape (n,), then ``fun`` must return array_like with
 |      shape (n,). Or alternatively it can have shape (n, n_points), then
 |      ``fun`` must return array_like with shape (n, n_points) (each column
 |      corresponds to a single column in ``y``). The choice between the two
 |      options is determined by `vectorized` argument (see below).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time --- the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  vectorized : bool
 |      Whether `fun` is implemented in a vectorized fashion.
 |  support_complex : bool, optional
 |      Whether integration in a complex domain should be supported.
 |      Generally determined by a derived solver class capabilities.
 |      Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number of the system's rhs evaluations.
 |  njev : int
 |      Number of the Jacobian evaluations.
 |  nlu : int
 |      Number of LU decompositions.
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, vectorized, support_complex=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('(self, fun, t0, y0, t_bound, vectorized, support_complex=False)',)",scipy,1.1.0,scipy.integrate._ivp.ivp.OdeSolver,integrate._ivp.ivp,OdeSolver,"Python Library Documentation: class OdeSolver in module scipy.integrate._ivp.base

class OdeSolver(builtins.object)
 |  Base class for ODE solvers.
 |  
 |  In order to implement a new solver you need to follow the guidelines:
 |  
 |      1. A constructor must accept parameters presented in the base class
 |         (listed below) along with any other parameters specific to a solver.
 |      2. A constructor must accept arbitrary extraneous arguments
 |         ``**extraneous``, but warn that these arguments are irrelevant
 |         using `common.warn_extraneous` function. Do not pass these
 |         arguments to the base class.
 |      3. A solver must implement a private method `_step_impl(self)` which
 |         propagates a solver one step further. It must return tuple
 |         ``(success, message)``, where ``success`` is a boolean indicating
 |         whether a step was successful, and ``message`` is a string
 |         containing description of a failure if a step failed or None
 |         otherwise.
 |      4. A solver must implement a private method `_dense_output_impl(self)`
 |         which returns a `DenseOutput` object covering the last successful
 |         step.
 |      5. A solver must have attributes listed below in Attributes section.
 |         Note that `t_old` and `step_size` are updated automatically.
 |      6. Use `fun(self, t, y)` method for the system rhs evaluation, this
 |         way the number of function evaluations (`nfev`) will be tracked
 |         automatically.
 |      7. For convenience a base class provides `fun_single(self, t, y)` and
 |         `fun_vectorized(self, t, y)` for evaluating the rhs in
 |         non-vectorized and vectorized fashions respectively (regardless of
 |         how `fun` from the constructor is implemented). These calls don't
 |         increment `nfev`.
 |      8. If a solver uses a Jacobian matrix and LU decompositions, it should
 |         track the number of Jacobian evaluations (`njev`) and the number of
 |         LU decompositions (`nlu`).
 |      9. By convention the function evaluations used to compute a finite
 |         difference approximation of the Jacobian should not be counted in
 |         `nfev`, thus use `fun_single(self, t, y)` or
 |         `fun_vectorized(self, t, y)` when computing a finite difference
 |         approximation of the Jacobian.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar and there are two options for ndarray ``y``.
 |      It can either have shape (n,), then ``fun`` must return array_like with
 |      shape (n,). Or alternatively it can have shape (n, n_points), then
 |      ``fun`` must return array_like with shape (n, n_points) (each column
 |      corresponds to a single column in ``y``). The choice between the two
 |      options is determined by `vectorized` argument (see below).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time --- the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  vectorized : bool
 |      Whether `fun` is implemented in a vectorized fashion.
 |  support_complex : bool, optional
 |      Whether integration in a complex domain should be supported.
 |      Generally determined by a derived solver class capabilities.
 |      Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number of the system's rhs evaluations.
 |  njev : int
 |      Number of the Jacobian evaluations.
 |  nlu : int
 |      Number of LU decompositions.
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, vectorized, support_complex=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('self', 'fun', 't0', 'y0', 't_bound', 'vectorized', 'support_complex')","(nan, nan, nan, nan, nan, nan, False)","(nan, nan, nan, nan, nan, nan, 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, fun, t0, y0, t_bound, vectorized, support_complex=False)',)"
scipy,1.1.0,scipy.integrate._ivp.ivp.OptimizeResult,integrate._ivp.ivp,OptimizeResult,"Python Library Documentation: class OptimizeResult in module scipy.optimize.optimize

class OptimizeResult(builtins.dict)
 |  Represents the optimization result.
 |  
 |  Attributes
 |  ----------
 |  x : ndarray
 |      The solution of the optimization.
 |  success : bool
 |      Whether or not the optimizer exited successfully.
 |  status : int
 |      Termination status of the optimizer. Its value depends on the
 |      underlying solver. Refer to `message` for details.
 |  message : str
 |      Description of the cause of the termination.
 |  fun, jac, hess: ndarray
 |      Values of objective function, its Jacobian and its Hessian (if
 |      available). The Hessians may be approximations, see the documentation
 |      of the function in question.
 |  hess_inv : object
 |      Inverse of the objective function's Hessian; may be an approximation.
 |      Not available for all solvers. The type of this attribute may be
 |      either np.ndarray or scipy.sparse.linalg.LinearOperator.
 |  nfev, njev, nhev : int
 |      Number of evaluations of the objective functions and of its
 |      Jacobian and Hessian.
 |  nit : int
 |      Number of iterations performed by the optimizer.
 |  maxcv : float
 |      The maximum constraint violation.
 |  
 |  Notes
 |  -----
 |  There may be additional attributes not listed above depending of the
 |  specific solver. Since this class is essentially a subclass of dict
 |  with attribute accessors, one can see which attributes are available
 |  using the `keys()` method.
 |  
 |  Method resolution order:
 |      OptimizeResult
 |      builtins.dict
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __delattr__ = __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __dir__(self)
 |      __dir__() -> list
 |      default dir() implementation
 |  
 |  __getattr__(self, name)
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __setattr__ = __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.dict:
 |  
 |  __contains__(self, key, /)
 |      True if D has a key k, else False.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __sizeof__(...)
 |      D.__sizeof__() -> size of D in memory, in bytes
 |  
 |  clear(...)
 |      D.clear() -> None.  Remove all items from D.
 |  
 |  copy(...)
 |      D.copy() -> a shallow copy of D
 |  
 |  fromkeys(iterable, value=None, /) from builtins.type
 |      Returns a new dict with keys from iterable and values equal to value.
 |  
 |  get(...)
 |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
 |  
 |  items(...)
 |      D.items() -> a set-like object providing a view on D's items
 |  
 |  keys(...)
 |      D.keys() -> a set-like object providing a view on D's keys
 |  
 |  pop(...)
 |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
 |      If key is not found, d is returned if given, otherwise KeyError is raised
 |  
 |  popitem(...)
 |      D.popitem() -> (k, v), remove and return some (key, value) pair as a
 |      2-tuple; but raise KeyError if D is empty.
 |  
 |  setdefault(...)
 |      D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
 |  
 |  update(...)
 |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
 |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
 |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
 |      In either case, this is followed by: for k in F:  D[k] = F[k]
 |  
 |  values(...)
 |      D.values() -> an object providing a view on D's values
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from builtins.dict:
 |  
 |  __hash__ = None
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.integrate._ivp.ivp.OptimizeResult,integrate._ivp.ivp,OptimizeResult,"Python Library Documentation: class OptimizeResult in module scipy.optimize.optimize

class OptimizeResult(builtins.dict)
 |  Represents the optimization result.
 |  
 |  Attributes
 |  ----------
 |  x : ndarray
 |      The solution of the optimization.
 |  success : bool
 |      Whether or not the optimizer exited successfully.
 |  status : int
 |      Termination status of the optimizer. Its value depends on the
 |      underlying solver. Refer to `message` for details.
 |  message : str
 |      Description of the cause of the termination.
 |  fun, jac, hess: ndarray
 |      Values of objective function, its Jacobian and its Hessian (if
 |      available). The Hessians may be approximations, see the documentation
 |      of the function in question.
 |  hess_inv : object
 |      Inverse of the objective function's Hessian; may be an approximation.
 |      Not available for all solvers. The type of this attribute may be
 |      either np.ndarray or scipy.sparse.linalg.LinearOperator.
 |  nfev, njev, nhev : int
 |      Number of evaluations of the objective functions and of its
 |      Jacobian and Hessian.
 |  nit : int
 |      Number of iterations performed by the optimizer.
 |  maxcv : float
 |      The maximum constraint violation.
 |  
 |  Notes
 |  -----
 |  There may be additional attributes not listed above depending of the
 |  specific solver. Since this class is essentially a subclass of dict
 |  with attribute accessors, one can see which attributes are available
 |  using the `keys()` method.
 |  
 |  Method resolution order:
 |      OptimizeResult
 |      builtins.dict
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __delattr__ = __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __dir__(self)
 |      __dir__() -> list
 |      default dir() implementation
 |  
 |  __getattr__(self, name)
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __setattr__ = __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.dict:
 |  
 |  __contains__(self, key, /)
 |      True if D has a key k, else False.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __sizeof__(...)
 |      D.__sizeof__() -> size of D in memory, in bytes
 |  
 |  clear(...)
 |      D.clear() -> None.  Remove all items from D.
 |  
 |  copy(...)
 |      D.copy() -> a shallow copy of D
 |  
 |  fromkeys(iterable, value=None, /) from builtins.type
 |      Returns a new dict with keys from iterable and values equal to value.
 |  
 |  get(...)
 |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
 |  
 |  items(...)
 |      D.items() -> a set-like object providing a view on D's items
 |  
 |  keys(...)
 |      D.keys() -> a set-like object providing a view on D's keys
 |  
 |  pop(...)
 |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
 |      If key is not found, d is returned if given, otherwise KeyError is raised
 |  
 |  popitem(...)
 |      D.popitem() -> (k, v), remove and return some (key, value) pair as a
 |      2-tuple; but raise KeyError if D is empty.
 |  
 |  setdefault(...)
 |      D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
 |  
 |  update(...)
 |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
 |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
 |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
 |      In either case, this is followed by: for k in F:  D[k] = F[k]
 |  
 |  values(...)
 |      D.values() -> an object providing a view on D's values
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from builtins.dict:
 |  
 |  __hash__ = None
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.integrate._ivp.ivp.RK23,integrate._ivp.ivp,RK23,"Python Library Documentation: class RK23 in module scipy.integrate._ivp.rk

class RK23(RungeKutta)
 |  Explicit Runge-Kutta method of order 3(2).
 |  
 |  This uses the Bogacki-Shampine pair of formulas [1]_. The error is controlled
 |  assuming accuracy of the second-order method, but steps are taken using the
 |  third-order accurate formula (local extrapolation is done). A cubic Hermite
 |  polynomial is used for the dense output.
 |  
 |  Can be applied in the complex domain.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar and there are two options for ndarray ``y``.
 |      It can either have shape (n,), then ``fun`` must return array_like with
 |      shape (n,). Or alternatively it can have shape (n, k), then ``fun``
 |      must return array_like with shape (n, k), i.e. each column
 |      corresponds to a single column in ``y``. The choice between the two
 |      options is determined by `vectorized` argument (see below).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time - the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  max_step : float, optional
 |      Maximum allowed step size. Default is np.inf, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  rtol, atol : float and array_like, optional
 |      Relative and absolute tolerances. The solver keeps the local error
 |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
 |      relative accuracy (number of correct digits). But if a component of `y`
 |      is approximately below `atol`, the error only needs to fall within
 |      the same `atol` threshold, and the number of correct digits is not
 |      guaranteed. If components of y have different scales, it might be
 |      beneficial to set different `atol` values for different components by
 |      passing array_like with shape (n,) for `atol`. Default values are
 |      1e-3 for `rtol` and 1e-6 for `atol`.
 |  vectorized : bool, optional
 |      Whether `fun` is implemented in a vectorized fashion. Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number evaluations of the system's right-hand side.
 |  njev : int
 |      Number of evaluations of the Jacobian. Is always 0 for this solver as it does not use the Jacobian.
 |  nlu : int
 |      Number of LU decompositions. Is always 0 for this solver.
 |  
 |  References
 |  ----------
 |  .. [1] P. Bogacki, L.F. Shampine, ""A 3(2) Pair of Runge-Kutta Formulas"",
 |         Appl. Math. Lett. Vol. 2, No. 4. pp. 321-325, 1989.
 |  
 |  Method resolution order:
 |      RK23
 |      RungeKutta
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Data and other attributes defined here:
 |  
 |  A = [array([0.5]), array([0.  , 0.75])]
 |  
 |  B = array([0.22222222, 0.33333333, 0.44444444])
 |  
 |  C = array([0.5 , 0.75])
 |  
 |  E = array([ 0.06944444, -0.08333333, -0.11111111,  0.125     ])
 |  
 |  P = array([[ 1.        , -1.33333333,  0.55555556],
 |  ...
 |         [ 0.   ...
 |  
 |  n_stages = 3
 |  
 |  order = 2
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from RungeKutta:
 |  
 |  __init__(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, vectorized=False, **extraneous)',)",scipy,1.1.0,scipy.integrate._ivp.ivp.RK23,integrate._ivp.ivp,RK23,"Python Library Documentation: class RK23 in module scipy.integrate._ivp.rk

class RK23(RungeKutta)
 |  Explicit Runge-Kutta method of order 3(2).
 |  
 |  This uses the Bogacki-Shampine pair of formulas [1]_. The error is controlled
 |  assuming accuracy of the second-order method, but steps are taken using the
 |  third-order accurate formula (local extrapolation is done). A cubic Hermite
 |  polynomial is used for the dense output.
 |  
 |  Can be applied in the complex domain.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar and there are two options for ndarray ``y``.
 |      It can either have shape (n,), then ``fun`` must return array_like with
 |      shape (n,). Or alternatively it can have shape (n, k), then ``fun``
 |      must return array_like with shape (n, k), i.e. each column
 |      corresponds to a single column in ``y``. The choice between the two
 |      options is determined by `vectorized` argument (see below).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time - the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  max_step : float, optional
 |      Maximum allowed step size. Default is np.inf, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  rtol, atol : float and array_like, optional
 |      Relative and absolute tolerances. The solver keeps the local error
 |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
 |      relative accuracy (number of correct digits). But if a component of `y`
 |      is approximately below `atol`, the error only needs to fall within
 |      the same `atol` threshold, and the number of correct digits is not
 |      guaranteed. If components of y have different scales, it might be
 |      beneficial to set different `atol` values for different components by
 |      passing array_like with shape (n,) for `atol`. Default values are
 |      1e-3 for `rtol` and 1e-6 for `atol`.
 |  vectorized : bool, optional
 |      Whether `fun` is implemented in a vectorized fashion. Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number evaluations of the system's right-hand side.
 |  njev : int
 |      Number of evaluations of the Jacobian. Is always 0 for this solver as it does not use the Jacobian.
 |  nlu : int
 |      Number of LU decompositions. Is always 0 for this solver.
 |  
 |  References
 |  ----------
 |  .. [1] P. Bogacki, L.F. Shampine, ""A 3(2) Pair of Runge-Kutta Formulas"",
 |         Appl. Math. Lett. Vol. 2, No. 4. pp. 321-325, 1989.
 |  
 |  Method resolution order:
 |      RK23
 |      RungeKutta
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Data and other attributes defined here:
 |  
 |  A = [array([0.5]), array([0.  , 0.75])]
 |  
 |  B = array([0.22222222, 0.33333333, 0.44444444])
 |  
 |  C = array([0.5 , 0.75])
 |  
 |  E = array([ 0.06944444, -0.08333333, -0.11111111,  0.125     ])
 |  
 |  P = array([[ 1.        , -1.33333333,  0.55555556],
 |  ...
 |         [ 0.   ...
 |  
 |  n_stages = 3
 |  
 |  order = 2
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from RungeKutta:
 |  
 |  __init__(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('self', 'fun', 't0', 'y0', 't_bound', 'max_step', 'rtol', 'atol', 'vectorized')","(nan, nan, nan, nan, nan, inf, 0.001, 1e-06, False)","(nan, nan, nan, nan, nan, 'float', 'float', 'float', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, vectorized=False, **extraneous)',)"
scipy,1.1.0,scipy.integrate._ivp.ivp.RK45,integrate._ivp.ivp,RK45,"Python Library Documentation: class RK45 in module scipy.integrate._ivp.rk

class RK45(RungeKutta)
 |  Explicit Runge-Kutta method of order 5(4).
 |  
 |  This uses the Dormand-Prince pair of formulas [1]_. The error is controlled
 |  assuming accuracy of the fourth-order method accuracy, but steps are taken
 |  using the fifth-order accurate formula (local extrapolation is done).
 |  A quartic interpolation polynomial is used for the dense output [2]_.
 |  
 |  Can be applied in the complex domain.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar, and there are two options for the ndarray ``y``:
 |      It can either have shape (n,); then ``fun`` must return array_like with
 |      shape (n,). Alternatively it can have shape (n, k); then ``fun``
 |      must return an array_like with shape (n, k), i.e. each column
 |      corresponds to a single column in ``y``. The choice between the two
 |      options is determined by `vectorized` argument (see below).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time - the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  max_step : float, optional
 |      Maximum allowed step size. Default is np.inf, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  rtol, atol : float and array_like, optional
 |      Relative and absolute tolerances. The solver keeps the local error
 |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
 |      relative accuracy (number of correct digits). But if a component of `y`
 |      is approximately below `atol`, the error only needs to fall within
 |      the same `atol` threshold, and the number of correct digits is not
 |      guaranteed. If components of y have different scales, it might be
 |      beneficial to set different `atol` values for different components by
 |      passing array_like with shape (n,) for `atol`. Default values are
 |      1e-3 for `rtol` and 1e-6 for `atol`.
 |  vectorized : bool, optional
 |      Whether `fun` is implemented in a vectorized fashion. Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number evaluations of the system's right-hand side.
 |  njev : int
 |      Number of evaluations of the Jacobian. Is always 0 for this solver as it does not use the Jacobian.
 |  nlu : int
 |      Number of LU decompositions. Is always 0 for this solver.
 |  
 |  References
 |  ----------
 |  .. [1] J. R. Dormand, P. J. Prince, ""A family of embedded Runge-Kutta
 |         formulae"", Journal of Computational and Applied Mathematics, Vol. 6,
 |         No. 1, pp. 19-26, 1980.
 |  .. [2] L. W. Shampine, ""Some Practical Runge-Kutta Formulas"", Mathematics
 |         of Computation,, Vol. 46, No. 173, pp. 135-150, 1986.
 |  
 |  Method resolution order:
 |      RK45
 |      RungeKutta
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Data and other attributes defined here:
 |  
 |  A = [array([0.2]), array([0.075, 0.225]), array([ 0.97777778, -3.73333...
 |  
 |  B = array([ 0.09114583,  0.        ,  0.4492363 ,  0.65104167, -0.3223...
 |  
 |  C = array([0.2       , 0.3       , 0.8       , 0.88888889, 1.        ]...
 |  
 |  E = array([-0.00123264,  0.        ,  0.00425277, -0...7,  0.0508638 ,...
 |  
 |  P = array([[ 1.        , -2.85358007,  3.07174346, -...       ,  1.382...
 |  
 |  n_stages = 6
 |  
 |  order = 4
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from RungeKutta:
 |  
 |  __init__(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, vectorized=False, **extraneous)',)",scipy,1.1.0,scipy.integrate._ivp.ivp.RK45,integrate._ivp.ivp,RK45,"Python Library Documentation: class RK45 in module scipy.integrate._ivp.rk

class RK45(RungeKutta)
 |  Explicit Runge-Kutta method of order 5(4).
 |  
 |  This uses the Dormand-Prince pair of formulas [1]_. The error is controlled
 |  assuming accuracy of the fourth-order method accuracy, but steps are taken
 |  using the fifth-order accurate formula (local extrapolation is done).
 |  A quartic interpolation polynomial is used for the dense output [2]_.
 |  
 |  Can be applied in the complex domain.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar, and there are two options for the ndarray ``y``:
 |      It can either have shape (n,); then ``fun`` must return array_like with
 |      shape (n,). Alternatively it can have shape (n, k); then ``fun``
 |      must return an array_like with shape (n, k), i.e. each column
 |      corresponds to a single column in ``y``. The choice between the two
 |      options is determined by `vectorized` argument (see below).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time - the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  max_step : float, optional
 |      Maximum allowed step size. Default is np.inf, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  rtol, atol : float and array_like, optional
 |      Relative and absolute tolerances. The solver keeps the local error
 |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
 |      relative accuracy (number of correct digits). But if a component of `y`
 |      is approximately below `atol`, the error only needs to fall within
 |      the same `atol` threshold, and the number of correct digits is not
 |      guaranteed. If components of y have different scales, it might be
 |      beneficial to set different `atol` values for different components by
 |      passing array_like with shape (n,) for `atol`. Default values are
 |      1e-3 for `rtol` and 1e-6 for `atol`.
 |  vectorized : bool, optional
 |      Whether `fun` is implemented in a vectorized fashion. Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number evaluations of the system's right-hand side.
 |  njev : int
 |      Number of evaluations of the Jacobian. Is always 0 for this solver as it does not use the Jacobian.
 |  nlu : int
 |      Number of LU decompositions. Is always 0 for this solver.
 |  
 |  References
 |  ----------
 |  .. [1] J. R. Dormand, P. J. Prince, ""A family of embedded Runge-Kutta
 |         formulae"", Journal of Computational and Applied Mathematics, Vol. 6,
 |         No. 1, pp. 19-26, 1980.
 |  .. [2] L. W. Shampine, ""Some Practical Runge-Kutta Formulas"", Mathematics
 |         of Computation,, Vol. 46, No. 173, pp. 135-150, 1986.
 |  
 |  Method resolution order:
 |      RK45
 |      RungeKutta
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Data and other attributes defined here:
 |  
 |  A = [array([0.2]), array([0.075, 0.225]), array([ 0.97777778, -3.73333...
 |  
 |  B = array([ 0.09114583,  0.        ,  0.4492363 ,  0.65104167, -0.3223...
 |  
 |  C = array([0.2       , 0.3       , 0.8       , 0.88888889, 1.        ]...
 |  
 |  E = array([-0.00123264,  0.        ,  0.00425277, -0...7,  0.0508638 ,...
 |  
 |  P = array([[ 1.        , -2.85358007,  3.07174346, -...       ,  1.382...
 |  
 |  n_stages = 6
 |  
 |  order = 4
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from RungeKutta:
 |  
 |  __init__(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('self', 'fun', 't0', 'y0', 't_bound', 'max_step', 'rtol', 'atol', 'vectorized')","(nan, nan, nan, nan, nan, inf, 0.001, 1e-06, False)","(nan, nan, nan, nan, nan, 'float', 'float', 'float', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, vectorized=False, **extraneous)',)"
scipy,1.1.0,scipy.integrate._ivp.ivp.Radau,integrate._ivp.ivp,Radau,"Python Library Documentation: class Radau in module scipy.integrate._ivp.radau

class Radau(scipy.integrate._ivp.base.OdeSolver)
 |  Implicit Runge-Kutta method of Radau IIA family of order 5.
 |  
 |  The implementation follows [1]_. The error is controlled with a
 |  third-order accurate embedded formula. A cubic polynomial which satisfies
 |  the collocation conditions is used for the dense output.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar, and there are two options for the ndarray ``y``:
 |      It can either have shape (n,); then ``fun`` must return array_like with
 |      shape (n,). Alternatively it can have shape (n, k); then ``fun``
 |      must return an array_like with shape (n, k), i.e. each column
 |      corresponds to a single column in ``y``. The choice between the two
 |      options is determined by `vectorized` argument (see below). The
 |      vectorized implementation allows a faster approximation of the Jacobian
 |      by finite differences (required for this solver).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time - the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  max_step : float, optional
 |      Maximum allowed step size. Default is np.inf, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  rtol, atol : float and array_like, optional
 |      Relative and absolute tolerances. The solver keeps the local error
 |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
 |      relative accuracy (number of correct digits). But if a component of `y`
 |      is approximately below `atol`, the error only needs to fall within
 |      the same `atol` threshold, and the number of correct digits is not
 |      guaranteed. If components of y have different scales, it might be
 |      beneficial to set different `atol` values for different components by
 |      passing array_like with shape (n,) for `atol`. Default values are
 |      1e-3 for `rtol` and 1e-6 for `atol`.
 |  jac : {None, array_like, sparse_matrix, callable}, optional
 |      Jacobian matrix of the right-hand side of the system with respect to
 |      y, required by this method. The Jacobian matrix has shape (n, n) and
 |      its element (i, j) is equal to ``d f_i / d y_j``.
 |      There are three ways to define the Jacobian:
 |  
 |          * If array_like or sparse_matrix, the Jacobian is assumed to
 |            be constant.
 |          * If callable, the Jacobian is assumed to depend on both
 |            t and y; it will be called as ``jac(t, y)`` as necessary.
 |            For the 'Radau' and 'BDF' methods, the return value might be a
 |            sparse matrix.
 |          * If None (default), the Jacobian will be approximated by
 |            finite differences.
 |  
 |      It is generally recommended to provide the Jacobian rather than
 |      relying on a finite-difference approximation.
 |  jac_sparsity : {None, array_like, sparse matrix}, optional
 |      Defines a sparsity structure of the Jacobian matrix for a
 |      finite-difference approximation. Its shape must be (n, n). This argument
 |      is ignored if `jac` is not `None`. If the Jacobian has only few non-zero
 |      elements in *each* row, providing the sparsity structure will greatly
 |      speed up the computations [2]_. A zero entry means that a corresponding
 |      element in the Jacobian is always zero. If None (default), the Jacobian
 |      is assumed to be dense.
 |  vectorized : bool, optional
 |      Whether `fun` is implemented in a vectorized fashion. Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number of evaluations of the right-hand side.
 |  njev : int
 |      Number of evaluations of the Jacobian.
 |  nlu : int
 |      Number of LU decompositions.
 |  
 |  References
 |  ----------
 |  .. [1] E. Hairer, G. Wanner, ""Solving Ordinary Differential Equations II:
 |         Stiff and Differential-Algebraic Problems"", Sec. IV.8.
 |  .. [2] A. Curtis, M. J. D. Powell, and J. Reid, ""On the estimation of
 |         sparse Jacobian matrices"", Journal of the Institute of Mathematics
 |         and its Applications, 13, pp. 117-120, 1974.
 |  
 |  Method resolution order:
 |      Radau
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, jac=None, jac_sparsity=None, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, jac=None, jac_sparsity=None, vectorized=False, **extraneous)',)",scipy,1.1.0,scipy.integrate._ivp.ivp.Radau,integrate._ivp.ivp,Radau,"Python Library Documentation: class Radau in module scipy.integrate._ivp.radau

class Radau(scipy.integrate._ivp.base.OdeSolver)
 |  Implicit Runge-Kutta method of Radau IIA family of order 5.
 |  
 |  The implementation follows [1]_. The error is controlled with a
 |  third-order accurate embedded formula. A cubic polynomial which satisfies
 |  the collocation conditions is used for the dense output.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar, and there are two options for the ndarray ``y``:
 |      It can either have shape (n,); then ``fun`` must return array_like with
 |      shape (n,). Alternatively it can have shape (n, k); then ``fun``
 |      must return an array_like with shape (n, k), i.e. each column
 |      corresponds to a single column in ``y``. The choice between the two
 |      options is determined by `vectorized` argument (see below). The
 |      vectorized implementation allows a faster approximation of the Jacobian
 |      by finite differences (required for this solver).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time - the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  max_step : float, optional
 |      Maximum allowed step size. Default is np.inf, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  rtol, atol : float and array_like, optional
 |      Relative and absolute tolerances. The solver keeps the local error
 |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
 |      relative accuracy (number of correct digits). But if a component of `y`
 |      is approximately below `atol`, the error only needs to fall within
 |      the same `atol` threshold, and the number of correct digits is not
 |      guaranteed. If components of y have different scales, it might be
 |      beneficial to set different `atol` values for different components by
 |      passing array_like with shape (n,) for `atol`. Default values are
 |      1e-3 for `rtol` and 1e-6 for `atol`.
 |  jac : {None, array_like, sparse_matrix, callable}, optional
 |      Jacobian matrix of the right-hand side of the system with respect to
 |      y, required by this method. The Jacobian matrix has shape (n, n) and
 |      its element (i, j) is equal to ``d f_i / d y_j``.
 |      There are three ways to define the Jacobian:
 |  
 |          * If array_like or sparse_matrix, the Jacobian is assumed to
 |            be constant.
 |          * If callable, the Jacobian is assumed to depend on both
 |            t and y; it will be called as ``jac(t, y)`` as necessary.
 |            For the 'Radau' and 'BDF' methods, the return value might be a
 |            sparse matrix.
 |          * If None (default), the Jacobian will be approximated by
 |            finite differences.
 |  
 |      It is generally recommended to provide the Jacobian rather than
 |      relying on a finite-difference approximation.
 |  jac_sparsity : {None, array_like, sparse matrix}, optional
 |      Defines a sparsity structure of the Jacobian matrix for a
 |      finite-difference approximation. Its shape must be (n, n). This argument
 |      is ignored if `jac` is not `None`. If the Jacobian has only few non-zero
 |      elements in *each* row, providing the sparsity structure will greatly
 |      speed up the computations [2]_. A zero entry means that a corresponding
 |      element in the Jacobian is always zero. If None (default), the Jacobian
 |      is assumed to be dense.
 |  vectorized : bool, optional
 |      Whether `fun` is implemented in a vectorized fashion. Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number of evaluations of the right-hand side.
 |  njev : int
 |      Number of evaluations of the Jacobian.
 |  nlu : int
 |      Number of LU decompositions.
 |  
 |  References
 |  ----------
 |  .. [1] E. Hairer, G. Wanner, ""Solving Ordinary Differential Equations II:
 |         Stiff and Differential-Algebraic Problems"", Sec. IV.8.
 |  .. [2] A. Curtis, M. J. D. Powell, and J. Reid, ""On the estimation of
 |         sparse Jacobian matrices"", Journal of the Institute of Mathematics
 |         and its Applications, 13, pp. 117-120, 1974.
 |  
 |  Method resolution order:
 |      Radau
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, jac=None, jac_sparsity=None, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('self', 'fun', 't0', 'y0', 't_bound', 'max_step', 'rtol', 'atol', 'jac', 'jac_sparsity', 'vectorized')","(nan, nan, nan, nan, nan, inf, 0.001, 1e-06, None, None, False)","(nan, nan, nan, nan, nan, 'float', 'float', 'float', 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, jac=None, jac_sparsity=None, vectorized=False, **extraneous)',)"
scipy,1.1.0,scipy.integrate._ivp.ivp.find_active_events,integrate._ivp.ivp,find_active_events,"Python Library Documentation: function find_active_events in module scipy.integrate._ivp.ivp

find_active_events(g, g_new, direction)
    Find which event occurred during an integration step.
    
    Parameters
    ----------
    g, g_new : array_like, shape (n_events,)
        Values of event functions at a current and next points.
    direction : ndarray, shape (n_events,)
        Event ""direction"" according to the definition in `solve_ivp`.
    
    Returns
    -------
    active_events : ndarray
        Indices of events which occurred during the step.
",function,"('(g, g_new, direction)',)",scipy,1.1.0,scipy.integrate._ivp.ivp.find_active_events,integrate._ivp.ivp,find_active_events,"Python Library Documentation: function find_active_events in module scipy.integrate._ivp.ivp

find_active_events(g, g_new, direction)
    Find which event occurred during an integration step.
    
    Parameters
    ----------
    g, g_new : array_like, shape (n_events,)
        Values of event functions at a current and next points.
    direction : ndarray, shape (n_events,)
        Event ""direction"" according to the definition in `solve_ivp`.
    
    Returns
    -------
    active_events : ndarray
        Indices of events which occurred during the step.
",function,"('g', 'g_new', 'direction')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(g, g_new, direction)',)"
scipy,1.1.0,scipy.integrate._ivp.ivp.handle_events,integrate._ivp.ivp,handle_events,"Python Library Documentation: function handle_events in module scipy.integrate._ivp.ivp

handle_events(sol, events, active_events, is_terminal, t_old, t)
    Helper function to handle events.
    
    Parameters
    ----------
    sol : DenseOutput
        Function ``sol(t)`` which evaluates an ODE solution between `t_old`
        and  `t`.
    events : list of callables, length n_events
        Event functions with signatures ``event(t, y)``.
    active_events : ndarray
        Indices of events which occurred.
    is_terminal : ndarray, shape (n_events,)
        Which events are terminal.
    t_old, t : float
        Previous and new values of time.
    
    Returns
    -------
    root_indices : ndarray
        Indices of events which take zero between `t_old` and `t` and before
        a possible termination.
    roots : ndarray
        Values of t at which events occurred.
    terminate : bool
        Whether a terminal event occurred.
",function,"('(sol, events, active_events, is_terminal, t_old, t)',)",scipy,1.1.0,scipy.integrate._ivp.ivp.handle_events,integrate._ivp.ivp,handle_events,"Python Library Documentation: function handle_events in module scipy.integrate._ivp.ivp

handle_events(sol, events, active_events, is_terminal, t_old, t)
    Helper function to handle events.
    
    Parameters
    ----------
    sol : DenseOutput
        Function ``sol(t)`` which evaluates an ODE solution between `t_old`
        and  `t`.
    events : list of callables, length n_events
        Event functions with signatures ``event(t, y)``.
    active_events : ndarray
        Indices of events which occurred.
    is_terminal : ndarray, shape (n_events,)
        Which events are terminal.
    t_old, t : float
        Previous and new values of time.
    
    Returns
    -------
    root_indices : ndarray
        Indices of events which take zero between `t_old` and `t` and before
        a possible termination.
    roots : ndarray
        Values of t at which events occurred.
    terminate : bool
        Whether a terminal event occurred.
",function,"('sol', 'events', 'active_events', 'is_terminal', 't_old', 't')","(nan, nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(sol, events, active_events, is_terminal, t_old, t)',)"
scipy,1.1.0,scipy.integrate._ivp.ivp.prepare_events,integrate._ivp.ivp,prepare_events,"Python Library Documentation: function prepare_events in module scipy.integrate._ivp.ivp

prepare_events(events)
    Standardize event functions and extract is_terminal and direction.
",function,"('(events)',)",scipy,1.1.0,scipy.integrate._ivp.ivp.prepare_events,integrate._ivp.ivp,prepare_events,"Python Library Documentation: function prepare_events in module scipy.integrate._ivp.ivp

prepare_events(events)
    Standardize event functions and extract is_terminal and direction.
",function,"('events',)","(nan,)","(nan,)","('arg_info',)","('(events)',)"
scipy,1.1.0,scipy.integrate._ivp.ivp.solve_event_equation,integrate._ivp.ivp,solve_event_equation,"Python Library Documentation: function solve_event_equation in module scipy.integrate._ivp.ivp

solve_event_equation(event, sol, t_old, t)
    Solve an equation corresponding to an ODE event.
    
    The equation is ``event(t, y(t)) = 0``, here ``y(t)`` is known from an
    ODE solver using some sort of interpolation. It is solved by
    `scipy.optimize.brentq` with xtol=atol=4*EPS.
    
    Parameters
    ----------
    event : callable
        Function ``event(t, y)``.
    sol : callable
        Function ``sol(t)`` which evaluates an ODE solution between `t_old`
        and  `t`.
    t_old, t : float
        Previous and new values of time. They will be used as a bracketing
        interval.
    
    Returns
    -------
    root : float
        Found solution.
",function,"('(event, sol, t_old, t)',)",scipy,1.1.0,scipy.integrate._ivp.ivp.solve_event_equation,integrate._ivp.ivp,solve_event_equation,"Python Library Documentation: function solve_event_equation in module scipy.integrate._ivp.ivp

solve_event_equation(event, sol, t_old, t)
    Solve an equation corresponding to an ODE event.
    
    The equation is ``event(t, y(t)) = 0``, here ``y(t)`` is known from an
    ODE solver using some sort of interpolation. It is solved by
    `scipy.optimize.brentq` with xtol=atol=4*EPS.
    
    Parameters
    ----------
    event : callable
        Function ``event(t, y)``.
    sol : callable
        Function ``sol(t)`` which evaluates an ODE solution between `t_old`
        and  `t`.
    t_old, t : float
        Previous and new values of time. They will be used as a bracketing
        interval.
    
    Returns
    -------
    root : float
        Found solution.
",function,"('event', 'sol', 't_old', 't')","(nan, nan, nan, nan)","(nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(event, sol, t_old, t)',)"
scipy,1.1.0,scipy.integrate._ivp.ivp.solve_ivp,integrate._ivp.ivp,solve_ivp,"Python Library Documentation: function solve_ivp in module scipy.integrate._ivp.ivp

solve_ivp(fun, t_span, y0, method='RK45', t_eval=None, dense_output=False, events=None, vectorized=False, **options)
    Solve an initial value problem for a system of ODEs.
    
    This function numerically integrates a system of ordinary differential
    equations given an initial value::
    
        dy / dt = f(t, y)
        y(t0) = y0
    
    Here t is a one-dimensional independent variable (time), y(t) is an
    n-dimensional vector-valued function (state), and an n-dimensional
    vector-valued function f(t, y) determines the differential equations.
    The goal is to find y(t) approximately satisfying the differential
    equations, given an initial value y(t0)=y0.
    
    Some of the solvers support integration in the complex domain, but note that
    for stiff ODE solvers, the right-hand side must be complex-differentiable
    (satisfy Cauchy-Riemann equations [11]_). To solve a problem in the complex
    domain, pass y0 with a complex data type. Another option is always to
    rewrite your problem for real and imaginary parts separately.
    
    Parameters
    ----------
    fun : callable
        Right-hand side of the system. The calling signature is ``fun(t, y)``.
        Here ``t`` is a scalar, and there are two options for the ndarray ``y``:
        It can either have shape (n,); then ``fun`` must return array_like with
        shape (n,). Alternatively it can have shape (n, k); then ``fun``
        must return an array_like with shape (n, k), i.e. each column
        corresponds to a single column in ``y``. The choice between the two
        options is determined by `vectorized` argument (see below). The
        vectorized implementation allows a faster approximation of the Jacobian
        by finite differences (required for stiff solvers).
    t_span : 2-tuple of floats
        Interval of integration (t0, tf). The solver starts with t=t0 and
        integrates until it reaches t=tf.
    y0 : array_like, shape (n,)
        Initial state. For problems in the complex domain, pass `y0` with a
        complex data type (even if the initial guess is purely real).
    method : string or `OdeSolver`, optional
        Integration method to use:
    
            * 'RK45' (default): Explicit Runge-Kutta method of order 5(4) [1]_.
              The error is controlled assuming accuracy of the fourth-order
              method, but steps are taken using the fifth-order accurate formula
              (local extrapolation is done). A quartic interpolation polynomial
              is used for the dense output [2]_. Can be applied in the complex domain.
            * 'RK23': Explicit Runge-Kutta method of order 3(2) [3]_. The error
              is controlled assuming accuracy of the second-order method, but
              steps are taken using the third-order accurate formula (local
              extrapolation is done). A cubic Hermite polynomial is used for the
              dense output. Can be applied in the complex domain.
            * 'Radau': Implicit Runge-Kutta method of the Radau IIA family of
              order 5 [4]_. The error is controlled with a third-order accurate
              embedded formula. A cubic polynomial which satisfies the
              collocation conditions is used for the dense output.
            * 'BDF': Implicit multi-step variable-order (1 to 5) method based
              on a backward differentiation formula for the derivative
              approximation [5]_. The implementation follows the one described
              in [6]_. A quasi-constant step scheme is used and accuracy is
              enhanced using the NDF modification. Can be applied in the complex
              domain.
            * 'LSODA': Adams/BDF method with automatic stiffness detection and
              switching [7]_, [8]_. This is a wrapper of the Fortran solver
              from ODEPACK.
    
        You should use the 'RK45' or 'RK23' method for non-stiff problems and
        'Radau' or 'BDF' for stiff problems [9]_. If not sure, first try to run
        'RK45'. If needs unusually many iterations, diverges, or fails, your
        problem is likely to be stiff and you should use 'Radau' or 'BDF'.
        'LSODA' can also be a good universal choice, but it might be somewhat
        less convenient to work with as it wraps old Fortran code.
    
        You can also pass an arbitrary class derived from `OdeSolver` which
        implements the solver.
    dense_output : bool, optional
        Whether to compute a continuous solution. Default is False.
    t_eval : array_like or None, optional
        Times at which to store the computed solution, must be sorted and lie
        within `t_span`. If None (default), use points selected by the solver.
    events : callable, list of callables or None, optional
        Types of events to track. Each is defined by a continuous function of
        time and state that becomes zero value in case of an event. Each function
        must have the signature ``event(t, y)`` and return a float. The solver will
        find an accurate value of ``t`` at which ``event(t, y(t)) = 0`` using a
        root-finding algorithm. Additionally each ``event`` function might have
        the following attributes:
    
            * terminal: bool, whether to terminate integration if this
              event occurs. Implicitly False if not assigned.
            * direction: float, direction of a zero crossing. If `direction`
              is positive, `event` must go from negative to positive, and
              vice versa if `direction` is negative. If 0, then either direction
              will count. Implicitly 0 if not assigned.
    
        You can assign attributes like ``event.terminal = True`` to any
        function in Python. If None (default), events won't be tracked.
    vectorized : bool, optional
        Whether `fun` is implemented in a vectorized fashion. Default is False.
    options
        Options passed to a chosen solver. All options available for already
        implemented solvers are listed below.
    max_step : float, optional
        Maximum allowed step size. Default is np.inf, i.e. the step size is not
        bounded and determined solely by the solver.
    rtol, atol : float and array_like, optional
        Relative and absolute tolerances. The solver keeps the local error
        estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
        relative accuracy (number of correct digits). But if a component of `y`
        is approximately below `atol`, the error only needs to fall within
        the same `atol` threshold, and the number of correct digits is not
        guaranteed. If components of y have different scales, it might be
        beneficial to set different `atol` values for different components by
        passing array_like with shape (n,) for `atol`. Default values are
        1e-3 for `rtol` and 1e-6 for `atol`.
    jac : {None, array_like, sparse_matrix, callable}, optional
        Jacobian matrix of the right-hand side of the system with respect to
        y, required by the 'Radau', 'BDF' and 'LSODA' method. The Jacobian matrix
        has shape (n, n) and its element (i, j) is equal to ``d f_i / d y_j``.
        There are three ways to define the Jacobian:
    
            * If array_like or sparse_matrix, the Jacobian is assumed to
              be constant. Not supported by 'LSODA'.
            * If callable, the Jacobian is assumed to depend on both
              t and y; it will be called as ``jac(t, y)`` as necessary.
              For the 'Radau' and 'BDF' methods, the return value might be a
              sparse matrix.
            * If None (default), the Jacobian will be approximated by
              finite differences.
    
        It is generally recommended to provide the Jacobian rather than
        relying on a finite-difference approximation.
    jac_sparsity : {None, array_like, sparse matrix}, optional
        Defines a sparsity structure of the Jacobian matrix for a
        finite-difference approximation. Its shape must be (n, n). This argument
        is ignored if `jac` is not `None`. If the Jacobian has only few non-zero
        elements in *each* row, providing the sparsity structure will greatly
        speed up the computations [10]_. A zero entry means that a corresponding
        element in the Jacobian is always zero. If None (default), the Jacobian
        is assumed to be dense.
        Not supported by 'LSODA', see `lband` and `uband` instead.
    lband, uband : int or None
        Parameters defining the bandwidth of the Jacobian for the 'LSODA' method,
        i.e., ``jac[i, j] != 0 only for i - lband <= j <= i + uband``. Setting
        these requires your jac routine to return the Jacobian in the packed format:
        the returned array must have ``n`` columns and ``uband + lband + 1``
        rows in which Jacobian diagonals are written. Specifically
        ``jac_packed[uband + i - j , j] = jac[i, j]``. The same format is used
        in `scipy.linalg.solve_banded` (check for an illustration).
        These parameters can be also used with ``jac=None`` to reduce the
        number of Jacobian elements estimated by finite differences.
    min_step, first_step : float, optional
        The minimum allowed step size and the initial step size respectively
        for 'LSODA' method. By default `min_step` is zero and `first_step` is
        selected automatically.
    
    Returns
    -------
    Bunch object with the following fields defined:
    t : ndarray, shape (n_points,)
        Time points.
    y : ndarray, shape (n, n_points)
        Values of the solution at `t`.
    sol : `OdeSolution` or None
        Found solution as `OdeSolution` instance; None if `dense_output` was
        set to False.
    t_events : list of ndarray or None
        Contains for each event type a list of arrays at which an event of
        that type event was detected. None if `events` was None.
    nfev : int
        Number of evaluations of the right-hand side.
    njev : int
        Number of evaluations of the Jacobian.
    nlu : int
        Number of LU decompositions.
    status : int
        Reason for algorithm termination:
    
            * -1: Integration step failed.
            *  0: The solver successfully reached the end of `tspan`.
            *  1: A termination event occurred.
    
    message : string
        Human-readable description of the termination reason.
    success : bool
        True if the solver reached the interval end or a termination event
        occurred (``status >= 0``).
    
    References
    ----------
    .. [1] J. R. Dormand, P. J. Prince, ""A family of embedded Runge-Kutta
           formulae"", Journal of Computational and Applied Mathematics, Vol. 6,
           No. 1, pp. 19-26, 1980.
    .. [2] L. W. Shampine, ""Some Practical Runge-Kutta Formulas"", Mathematics
           of Computation,, Vol. 46, No. 173, pp. 135-150, 1986.
    .. [3] P. Bogacki, L.F. Shampine, ""A 3(2) Pair of Runge-Kutta Formulas"",
           Appl. Math. Lett. Vol. 2, No. 4. pp. 321-325, 1989.
    .. [4] E. Hairer, G. Wanner, ""Solving Ordinary Differential Equations II:
           Stiff and Differential-Algebraic Problems"", Sec. IV.8.
    .. [5] `Backward Differentiation Formula
            <https://en.wikipedia.org/wiki/Backward_differentiation_formula>`_
            on Wikipedia.
    .. [6] L. F. Shampine, M. W. Reichelt, ""THE MATLAB ODE SUITE"", SIAM J. SCI.
           COMPUTE., Vol. 18, No. 1, pp. 1-22, January 1997.
    .. [7] A. C. Hindmarsh, ""ODEPACK, A Systematized Collection of ODE
           Solvers,"" IMACS Transactions on Scientific Computation, Vol 1.,
           pp. 55-64, 1983.
    .. [8] L. Petzold, ""Automatic selection of methods for solving stiff and
           nonstiff systems of ordinary differential equations"", SIAM Journal
           on Scientific and Statistical Computing, Vol. 4, No. 1, pp. 136-148,
           1983.
    .. [9] `Stiff equation <https://en.wikipedia.org/wiki/Stiff_equation>`_ on
           Wikipedia.
    .. [10] A. Curtis, M. J. D. Powell, and J. Reid, ""On the estimation of
            sparse Jacobian matrices"", Journal of the Institute of Mathematics
            and its Applications, 13, pp. 117-120, 1974.
    .. [11] `Cauchy-Riemann equations
             <https://en.wikipedia.org/wiki/Cauchy-Riemann_equations>`_ on
             Wikipedia.
    
    Examples
    --------
    Basic exponential decay showing automatically chosen time points.
    
    >>> from scipy.integrate import solve_ivp
    >>> def exponential_decay(t, y): return -0.5 * y
    >>> sol = solve_ivp(exponential_decay, [0, 10], [2, 4, 8])
    >>> print(sol.t)
    [  0.           0.11487653   1.26364188   3.06061781   4.85759374
       6.65456967   8.4515456   10.        ]
    >>> print(sol.y)
    [[2.         1.88836035 1.06327177 0.43319312 0.17648948 0.0719045
      0.02929499 0.01350938]
     [4.         3.7767207  2.12654355 0.86638624 0.35297895 0.143809
      0.05858998 0.02701876]
     [8.         7.5534414  4.25308709 1.73277247 0.7059579  0.287618
      0.11717996 0.05403753]]
    
    Specifying points where the solution is desired.
    
    >>> sol = solve_ivp(exponential_decay, [0, 10], [2, 4, 8],
    ...                 t_eval=[0, 1, 2, 4, 10])
    >>> print(sol.t)
    [ 0  1  2  4 10]
    >>> print(sol.y)
    [[2.         1.21305369 0.73534021 0.27066736 0.01350938]
     [4.         2.42610739 1.47068043 0.54133472 0.02701876]
     [8.         4.85221478 2.94136085 1.08266944 0.05403753]]
    
    Cannon fired upward with terminal event upon impact. The ``terminal`` and
    ``direction`` fields of an event are applied by monkey patching a function.
    Here ``y[0]`` is position and ``y[1]`` is velocity. The projectile starts at
    position 0 with velocity +10. Note that the integration never reaches t=100
    because the event is terminal.
    
    >>> def upward_cannon(t, y): return [y[1], -0.5]
    >>> def hit_ground(t, y): return y[1]
    >>> hit_ground.terminal = True
    >>> hit_ground.direction = -1
    >>> sol = solve_ivp(upward_cannon, [0, 100], [0, 10], events=hit_ground)
    >>> print(sol.t_events)
    [array([ 20.])]
    >>> print(sol.t)
    [0.00000000e+00 9.99900010e-05 1.09989001e-03 1.10988901e-02
     1.11088891e-01 1.11098890e+00 1.11099890e+01 2.00000000e+01]
",function,"(""(fun, t_span, y0, method='RK45', t_eval=None, dense_output=False, events=None, vectorized=False, **options)"",)",scipy,1.1.0,scipy.integrate._ivp.ivp.solve_ivp,integrate._ivp.ivp,solve_ivp,"Python Library Documentation: function solve_ivp in module scipy.integrate._ivp.ivp

solve_ivp(fun, t_span, y0, method='RK45', t_eval=None, dense_output=False, events=None, vectorized=False, **options)
    Solve an initial value problem for a system of ODEs.
    
    This function numerically integrates a system of ordinary differential
    equations given an initial value::
    
        dy / dt = f(t, y)
        y(t0) = y0
    
    Here t is a one-dimensional independent variable (time), y(t) is an
    n-dimensional vector-valued function (state), and an n-dimensional
    vector-valued function f(t, y) determines the differential equations.
    The goal is to find y(t) approximately satisfying the differential
    equations, given an initial value y(t0)=y0.
    
    Some of the solvers support integration in the complex domain, but note that
    for stiff ODE solvers, the right-hand side must be complex-differentiable
    (satisfy Cauchy-Riemann equations [11]_). To solve a problem in the complex
    domain, pass y0 with a complex data type. Another option is always to
    rewrite your problem for real and imaginary parts separately.
    
    Parameters
    ----------
    fun : callable
        Right-hand side of the system. The calling signature is ``fun(t, y)``.
        Here ``t`` is a scalar, and there are two options for the ndarray ``y``:
        It can either have shape (n,); then ``fun`` must return array_like with
        shape (n,). Alternatively it can have shape (n, k); then ``fun``
        must return an array_like with shape (n, k), i.e. each column
        corresponds to a single column in ``y``. The choice between the two
        options is determined by `vectorized` argument (see below). The
        vectorized implementation allows a faster approximation of the Jacobian
        by finite differences (required for stiff solvers).
    t_span : 2-tuple of floats
        Interval of integration (t0, tf). The solver starts with t=t0 and
        integrates until it reaches t=tf.
    y0 : array_like, shape (n,)
        Initial state. For problems in the complex domain, pass `y0` with a
        complex data type (even if the initial guess is purely real).
    method : string or `OdeSolver`, optional
        Integration method to use:
    
            * 'RK45' (default): Explicit Runge-Kutta method of order 5(4) [1]_.
              The error is controlled assuming accuracy of the fourth-order
              method, but steps are taken using the fifth-order accurate formula
              (local extrapolation is done). A quartic interpolation polynomial
              is used for the dense output [2]_. Can be applied in the complex domain.
            * 'RK23': Explicit Runge-Kutta method of order 3(2) [3]_. The error
              is controlled assuming accuracy of the second-order method, but
              steps are taken using the third-order accurate formula (local
              extrapolation is done). A cubic Hermite polynomial is used for the
              dense output. Can be applied in the complex domain.
            * 'Radau': Implicit Runge-Kutta method of the Radau IIA family of
              order 5 [4]_. The error is controlled with a third-order accurate
              embedded formula. A cubic polynomial which satisfies the
              collocation conditions is used for the dense output.
            * 'BDF': Implicit multi-step variable-order (1 to 5) method based
              on a backward differentiation formula for the derivative
              approximation [5]_. The implementation follows the one described
              in [6]_. A quasi-constant step scheme is used and accuracy is
              enhanced using the NDF modification. Can be applied in the complex
              domain.
            * 'LSODA': Adams/BDF method with automatic stiffness detection and
              switching [7]_, [8]_. This is a wrapper of the Fortran solver
              from ODEPACK.
    
        You should use the 'RK45' or 'RK23' method for non-stiff problems and
        'Radau' or 'BDF' for stiff problems [9]_. If not sure, first try to run
        'RK45'. If needs unusually many iterations, diverges, or fails, your
        problem is likely to be stiff and you should use 'Radau' or 'BDF'.
        'LSODA' can also be a good universal choice, but it might be somewhat
        less convenient to work with as it wraps old Fortran code.
    
        You can also pass an arbitrary class derived from `OdeSolver` which
        implements the solver.
    dense_output : bool, optional
        Whether to compute a continuous solution. Default is False.
    t_eval : array_like or None, optional
        Times at which to store the computed solution, must be sorted and lie
        within `t_span`. If None (default), use points selected by the solver.
    events : callable, list of callables or None, optional
        Types of events to track. Each is defined by a continuous function of
        time and state that becomes zero value in case of an event. Each function
        must have the signature ``event(t, y)`` and return a float. The solver will
        find an accurate value of ``t`` at which ``event(t, y(t)) = 0`` using a
        root-finding algorithm. Additionally each ``event`` function might have
        the following attributes:
    
            * terminal: bool, whether to terminate integration if this
              event occurs. Implicitly False if not assigned.
            * direction: float, direction of a zero crossing. If `direction`
              is positive, `event` must go from negative to positive, and
              vice versa if `direction` is negative. If 0, then either direction
              will count. Implicitly 0 if not assigned.
    
        You can assign attributes like ``event.terminal = True`` to any
        function in Python. If None (default), events won't be tracked.
    vectorized : bool, optional
        Whether `fun` is implemented in a vectorized fashion. Default is False.
    options
        Options passed to a chosen solver. All options available for already
        implemented solvers are listed below.
    max_step : float, optional
        Maximum allowed step size. Default is np.inf, i.e. the step size is not
        bounded and determined solely by the solver.
    rtol, atol : float and array_like, optional
        Relative and absolute tolerances. The solver keeps the local error
        estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
        relative accuracy (number of correct digits). But if a component of `y`
        is approximately below `atol`, the error only needs to fall within
        the same `atol` threshold, and the number of correct digits is not
        guaranteed. If components of y have different scales, it might be
        beneficial to set different `atol` values for different components by
        passing array_like with shape (n,) for `atol`. Default values are
        1e-3 for `rtol` and 1e-6 for `atol`.
    jac : {None, array_like, sparse_matrix, callable}, optional
        Jacobian matrix of the right-hand side of the system with respect to
        y, required by the 'Radau', 'BDF' and 'LSODA' method. The Jacobian matrix
        has shape (n, n) and its element (i, j) is equal to ``d f_i / d y_j``.
        There are three ways to define the Jacobian:
    
            * If array_like or sparse_matrix, the Jacobian is assumed to
              be constant. Not supported by 'LSODA'.
            * If callable, the Jacobian is assumed to depend on both
              t and y; it will be called as ``jac(t, y)`` as necessary.
              For the 'Radau' and 'BDF' methods, the return value might be a
              sparse matrix.
            * If None (default), the Jacobian will be approximated by
              finite differences.
    
        It is generally recommended to provide the Jacobian rather than
        relying on a finite-difference approximation.
    jac_sparsity : {None, array_like, sparse matrix}, optional
        Defines a sparsity structure of the Jacobian matrix for a
        finite-difference approximation. Its shape must be (n, n). This argument
        is ignored if `jac` is not `None`. If the Jacobian has only few non-zero
        elements in *each* row, providing the sparsity structure will greatly
        speed up the computations [10]_. A zero entry means that a corresponding
        element in the Jacobian is always zero. If None (default), the Jacobian
        is assumed to be dense.
        Not supported by 'LSODA', see `lband` and `uband` instead.
    lband, uband : int or None
        Parameters defining the bandwidth of the Jacobian for the 'LSODA' method,
        i.e., ``jac[i, j] != 0 only for i - lband <= j <= i + uband``. Setting
        these requires your jac routine to return the Jacobian in the packed format:
        the returned array must have ``n`` columns and ``uband + lband + 1``
        rows in which Jacobian diagonals are written. Specifically
        ``jac_packed[uband + i - j , j] = jac[i, j]``. The same format is used
        in `scipy.linalg.solve_banded` (check for an illustration).
        These parameters can be also used with ``jac=None`` to reduce the
        number of Jacobian elements estimated by finite differences.
    min_step, first_step : float, optional
        The minimum allowed step size and the initial step size respectively
        for 'LSODA' method. By default `min_step` is zero and `first_step` is
        selected automatically.
    
    Returns
    -------
    Bunch object with the following fields defined:
    t : ndarray, shape (n_points,)
        Time points.
    y : ndarray, shape (n, n_points)
        Values of the solution at `t`.
    sol : `OdeSolution` or None
        Found solution as `OdeSolution` instance; None if `dense_output` was
        set to False.
    t_events : list of ndarray or None
        Contains for each event type a list of arrays at which an event of
        that type event was detected. None if `events` was None.
    nfev : int
        Number of evaluations of the right-hand side.
    njev : int
        Number of evaluations of the Jacobian.
    nlu : int
        Number of LU decompositions.
    status : int
        Reason for algorithm termination:
    
            * -1: Integration step failed.
            *  0: The solver successfully reached the end of `tspan`.
            *  1: A termination event occurred.
    
    message : string
        Human-readable description of the termination reason.
    success : bool
        True if the solver reached the interval end or a termination event
        occurred (``status >= 0``).
    
    References
    ----------
    .. [1] J. R. Dormand, P. J. Prince, ""A family of embedded Runge-Kutta
           formulae"", Journal of Computational and Applied Mathematics, Vol. 6,
           No. 1, pp. 19-26, 1980.
    .. [2] L. W. Shampine, ""Some Practical Runge-Kutta Formulas"", Mathematics
           of Computation,, Vol. 46, No. 173, pp. 135-150, 1986.
    .. [3] P. Bogacki, L.F. Shampine, ""A 3(2) Pair of Runge-Kutta Formulas"",
           Appl. Math. Lett. Vol. 2, No. 4. pp. 321-325, 1989.
    .. [4] E. Hairer, G. Wanner, ""Solving Ordinary Differential Equations II:
           Stiff and Differential-Algebraic Problems"", Sec. IV.8.
    .. [5] `Backward Differentiation Formula
            <https://en.wikipedia.org/wiki/Backward_differentiation_formula>`_
            on Wikipedia.
    .. [6] L. F. Shampine, M. W. Reichelt, ""THE MATLAB ODE SUITE"", SIAM J. SCI.
           COMPUTE., Vol. 18, No. 1, pp. 1-22, January 1997.
    .. [7] A. C. Hindmarsh, ""ODEPACK, A Systematized Collection of ODE
           Solvers,"" IMACS Transactions on Scientific Computation, Vol 1.,
           pp. 55-64, 1983.
    .. [8] L. Petzold, ""Automatic selection of methods for solving stiff and
           nonstiff systems of ordinary differential equations"", SIAM Journal
           on Scientific and Statistical Computing, Vol. 4, No. 1, pp. 136-148,
           1983.
    .. [9] `Stiff equation <https://en.wikipedia.org/wiki/Stiff_equation>`_ on
           Wikipedia.
    .. [10] A. Curtis, M. J. D. Powell, and J. Reid, ""On the estimation of
            sparse Jacobian matrices"", Journal of the Institute of Mathematics
            and its Applications, 13, pp. 117-120, 1974.
    .. [11] `Cauchy-Riemann equations
             <https://en.wikipedia.org/wiki/Cauchy-Riemann_equations>`_ on
             Wikipedia.
    
    Examples
    --------
    Basic exponential decay showing automatically chosen time points.
    
    >>> from scipy.integrate import solve_ivp
    >>> def exponential_decay(t, y): return -0.5 * y
    >>> sol = solve_ivp(exponential_decay, [0, 10], [2, 4, 8])
    >>> print(sol.t)
    [  0.           0.11487653   1.26364188   3.06061781   4.85759374
       6.65456967   8.4515456   10.        ]
    >>> print(sol.y)
    [[2.         1.88836035 1.06327177 0.43319312 0.17648948 0.0719045
      0.02929499 0.01350938]
     [4.         3.7767207  2.12654355 0.86638624 0.35297895 0.143809
      0.05858998 0.02701876]
     [8.         7.5534414  4.25308709 1.73277247 0.7059579  0.287618
      0.11717996 0.05403753]]
    
    Specifying points where the solution is desired.
    
    >>> sol = solve_ivp(exponential_decay, [0, 10], [2, 4, 8],
    ...                 t_eval=[0, 1, 2, 4, 10])
    >>> print(sol.t)
    [ 0  1  2  4 10]
    >>> print(sol.y)
    [[2.         1.21305369 0.73534021 0.27066736 0.01350938]
     [4.         2.42610739 1.47068043 0.54133472 0.02701876]
     [8.         4.85221478 2.94136085 1.08266944 0.05403753]]
    
    Cannon fired upward with terminal event upon impact. The ``terminal`` and
    ``direction`` fields of an event are applied by monkey patching a function.
    Here ``y[0]`` is position and ``y[1]`` is velocity. The projectile starts at
    position 0 with velocity +10. Note that the integration never reaches t=100
    because the event is terminal.
    
    >>> def upward_cannon(t, y): return [y[1], -0.5]
    >>> def hit_ground(t, y): return y[1]
    >>> hit_ground.terminal = True
    >>> hit_ground.direction = -1
    >>> sol = solve_ivp(upward_cannon, [0, 100], [0, 10], events=hit_ground)
    >>> print(sol.t_events)
    [array([ 20.])]
    >>> print(sol.t)
    [0.00000000e+00 9.99900010e-05 1.09989001e-03 1.10988901e-02
     1.11088891e-01 1.11098890e+00 1.11099890e+01 2.00000000e+01]
",function,"('fun', 't_span', 'y0', 'method', 't_eval', 'dense_output', 'events', 'vectorized')","(nan, nan, nan, 'RK45', None, False, None, False)","(nan, nan, nan, 'str', 'NoneType', 'bool', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(fun, t_span, y0, method='RK45', t_eval=None, dense_output=False, events=None, vectorized=False, **options)"",)"
scipy,1.1.0,scipy.integrate._ivp.lsoda.DenseOutput,integrate._ivp.lsoda,DenseOutput,"Python Library Documentation: class DenseOutput in module scipy.integrate._ivp.base

class DenseOutput(builtins.object)
 |  Base class for local interpolant over step made by an ODE solver.
 |  
 |  It interpolates between `t_min` and `t_max` (see Attributes below).
 |  Evaluation outside this interval is not forbidden, but the accuracy is not
 |  guaranteed.
 |  
 |  Attributes
 |  ----------
 |  t_min, t_max : float
 |      Time range of the interpolation.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, t)
 |      Evaluate the interpolant.
 |      
 |      Parameters
 |      ----------
 |      t : float or array_like with shape (n_points,)
 |          Points to evaluate the solution at.
 |      
 |      Returns
 |      -------
 |      y : ndarray, shape (n,) or (n, n_points)
 |          Computed values. Shape depends on whether `t` was a scalar or a
 |          1-d array.
 |  
 |  __init__(self, t_old, t)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, t_old, t)',)",scipy,1.1.0,scipy.integrate._ivp.lsoda.DenseOutput,integrate._ivp.lsoda,DenseOutput,"Python Library Documentation: class DenseOutput in module scipy.integrate._ivp.base

class DenseOutput(builtins.object)
 |  Base class for local interpolant over step made by an ODE solver.
 |  
 |  It interpolates between `t_min` and `t_max` (see Attributes below).
 |  Evaluation outside this interval is not forbidden, but the accuracy is not
 |  guaranteed.
 |  
 |  Attributes
 |  ----------
 |  t_min, t_max : float
 |      Time range of the interpolation.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, t)
 |      Evaluate the interpolant.
 |      
 |      Parameters
 |      ----------
 |      t : float or array_like with shape (n_points,)
 |          Points to evaluate the solution at.
 |      
 |      Returns
 |      -------
 |      y : ndarray, shape (n,) or (n, n_points)
 |          Computed values. Shape depends on whether `t` was a scalar or a
 |          1-d array.
 |  
 |  __init__(self, t_old, t)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 't_old', 't')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(self, t_old, t)',)"
scipy,1.1.0,scipy.integrate._ivp.lsoda.LSODA,integrate._ivp.lsoda,LSODA,"Python Library Documentation: class LSODA in module scipy.integrate._ivp.lsoda

class LSODA(scipy.integrate._ivp.base.OdeSolver)
 |  Adams/BDF method with automatic stiffness detection and switching.
 |  
 |  This is a wrapper to the Fortran solver from ODEPACK [1]_. It switches
 |  automatically between the nonstiff Adams method and the stiff BDF method.
 |  The method was originally detailed in [2]_.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar, and there are two options for the ndarray ``y``:
 |      It can either have shape (n,); then ``fun`` must return array_like with
 |      shape (n,). Alternatively it can have shape (n, k); then ``fun``
 |      must return an array_like with shape (n, k), i.e. each column
 |      corresponds to a single column in ``y``. The choice between the two
 |      options is determined by `vectorized` argument (see below). The
 |      vectorized implementation allows a faster approximation of the Jacobian
 |      by finite differences (required for this solver).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time - the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  first_step : float or None, optional
 |      Initial step size. Default is ``None`` which means that the algorithm
 |      should choose.
 |  min_step : float, optional
 |      Minimum allowed step size. Default is 0.0, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  max_step : float, optional
 |      Maximum allowed step size. Default is np.inf, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  rtol, atol : float and array_like, optional
 |      Relative and absolute tolerances. The solver keeps the local error
 |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
 |      relative accuracy (number of correct digits). But if a component of `y`
 |      is approximately below `atol`, the error only needs to fall within
 |      the same `atol` threshold, and the number of correct digits is not
 |      guaranteed. If components of y have different scales, it might be
 |      beneficial to set different `atol` values for different components by
 |      passing array_like with shape (n,) for `atol`. Default values are
 |      1e-3 for `rtol` and 1e-6 for `atol`.
 |  jac : None or callable, optional
 |      Jacobian matrix of the right-hand side of the system with respect to
 |      ``y``. The Jacobian matrix has shape (n, n) and its element (i, j) is
 |      equal to ``d f_i / d y_j``. The function will be called as
 |      ``jac(t, y)``. If None (default), the Jacobian will be
 |      approximated by finite differences. It is generally recommended to
 |      provide the Jacobian rather than relying on a finite-difference
 |      approximation.
 |  lband, uband : int or None
 |      Parameters defining the bandwidth of the Jacobian,
 |      i.e., ``jac[i, j] != 0 only for i - lband <= j <= i + uband``. Setting
 |      these requires your jac routine to return the Jacobian in the packed format:
 |      the returned array must have ``n`` columns and ``uband + lband + 1``
 |      rows in which Jacobian diagonals are written. Specifically
 |      ``jac_packed[uband + i - j , j] = jac[i, j]``. The same format is used
 |      in `scipy.linalg.solve_banded` (check for an illustration).
 |      These parameters can be also used with ``jac=None`` to reduce the
 |      number of Jacobian elements estimated by finite differences.
 |  vectorized : bool, optional
 |      Whether `fun` is implemented in a vectorized fashion. A vectorized
 |      implementation offers no advantages for this solver. Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  nfev : int
 |      Number of evaluations of the right-hand side.
 |  njev : int
 |      Number of evaluations of the Jacobian.
 |  
 |  References
 |  ----------
 |  .. [1] A. C. Hindmarsh, ""ODEPACK, A Systematized Collection of ODE
 |         Solvers,"" IMACS Transactions on Scientific Computation, Vol 1.,
 |         pp. 55-64, 1983.
 |  .. [2] L. Petzold, ""Automatic selection of methods for solving stiff and
 |         nonstiff systems of ordinary differential equations"", SIAM Journal
 |         on Scientific and Statistical Computing, Vol. 4, No. 1, pp. 136-148,
 |         1983.
 |  
 |  Method resolution order:
 |      LSODA
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, first_step=None, min_step=0.0, max_step=inf, rtol=0.001, atol=1e-06, jac=None, lband=None, uband=None, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('(self, fun, t0, y0, t_bound, first_step=None, min_step=0.0, max_step=inf, rtol=0.001, atol=1e-06, jac=None, lband=None, uband=None, vectorized=False, **extraneous)',)",scipy,1.1.0,scipy.integrate._ivp.lsoda.LSODA,integrate._ivp.lsoda,LSODA,"Python Library Documentation: class LSODA in module scipy.integrate._ivp.lsoda

class LSODA(scipy.integrate._ivp.base.OdeSolver)
 |  Adams/BDF method with automatic stiffness detection and switching.
 |  
 |  This is a wrapper to the Fortran solver from ODEPACK [1]_. It switches
 |  automatically between the nonstiff Adams method and the stiff BDF method.
 |  The method was originally detailed in [2]_.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar, and there are two options for the ndarray ``y``:
 |      It can either have shape (n,); then ``fun`` must return array_like with
 |      shape (n,). Alternatively it can have shape (n, k); then ``fun``
 |      must return an array_like with shape (n, k), i.e. each column
 |      corresponds to a single column in ``y``. The choice between the two
 |      options is determined by `vectorized` argument (see below). The
 |      vectorized implementation allows a faster approximation of the Jacobian
 |      by finite differences (required for this solver).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time - the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  first_step : float or None, optional
 |      Initial step size. Default is ``None`` which means that the algorithm
 |      should choose.
 |  min_step : float, optional
 |      Minimum allowed step size. Default is 0.0, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  max_step : float, optional
 |      Maximum allowed step size. Default is np.inf, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  rtol, atol : float and array_like, optional
 |      Relative and absolute tolerances. The solver keeps the local error
 |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
 |      relative accuracy (number of correct digits). But if a component of `y`
 |      is approximately below `atol`, the error only needs to fall within
 |      the same `atol` threshold, and the number of correct digits is not
 |      guaranteed. If components of y have different scales, it might be
 |      beneficial to set different `atol` values for different components by
 |      passing array_like with shape (n,) for `atol`. Default values are
 |      1e-3 for `rtol` and 1e-6 for `atol`.
 |  jac : None or callable, optional
 |      Jacobian matrix of the right-hand side of the system with respect to
 |      ``y``. The Jacobian matrix has shape (n, n) and its element (i, j) is
 |      equal to ``d f_i / d y_j``. The function will be called as
 |      ``jac(t, y)``. If None (default), the Jacobian will be
 |      approximated by finite differences. It is generally recommended to
 |      provide the Jacobian rather than relying on a finite-difference
 |      approximation.
 |  lband, uband : int or None
 |      Parameters defining the bandwidth of the Jacobian,
 |      i.e., ``jac[i, j] != 0 only for i - lband <= j <= i + uband``. Setting
 |      these requires your jac routine to return the Jacobian in the packed format:
 |      the returned array must have ``n`` columns and ``uband + lband + 1``
 |      rows in which Jacobian diagonals are written. Specifically
 |      ``jac_packed[uband + i - j , j] = jac[i, j]``. The same format is used
 |      in `scipy.linalg.solve_banded` (check for an illustration).
 |      These parameters can be also used with ``jac=None`` to reduce the
 |      number of Jacobian elements estimated by finite differences.
 |  vectorized : bool, optional
 |      Whether `fun` is implemented in a vectorized fashion. A vectorized
 |      implementation offers no advantages for this solver. Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  nfev : int
 |      Number of evaluations of the right-hand side.
 |  njev : int
 |      Number of evaluations of the Jacobian.
 |  
 |  References
 |  ----------
 |  .. [1] A. C. Hindmarsh, ""ODEPACK, A Systematized Collection of ODE
 |         Solvers,"" IMACS Transactions on Scientific Computation, Vol 1.,
 |         pp. 55-64, 1983.
 |  .. [2] L. Petzold, ""Automatic selection of methods for solving stiff and
 |         nonstiff systems of ordinary differential equations"", SIAM Journal
 |         on Scientific and Statistical Computing, Vol. 4, No. 1, pp. 136-148,
 |         1983.
 |  
 |  Method resolution order:
 |      LSODA
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, first_step=None, min_step=0.0, max_step=inf, rtol=0.001, atol=1e-06, jac=None, lband=None, uband=None, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('self', 'fun', 't0', 'y0', 't_bound', 'first_step', 'min_step', 'max_step', 'rtol', 'atol', 'jac', 'lband', 'uband', 'vectorized')","(nan, nan, nan, nan, nan, None, 0.0, inf, 0.001, 1e-06, None, None, None, False)","(nan, nan, nan, nan, nan, 'NoneType', 'float', 'float', 'float', 'float', 'NoneType', 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, fun, t0, y0, t_bound, first_step=None, min_step=0.0, max_step=inf, rtol=0.001, atol=1e-06, jac=None, lband=None, uband=None, vectorized=False, **extraneous)',)"
scipy,1.1.0,scipy.integrate._ivp.lsoda.LsodaDenseOutput,integrate._ivp.lsoda,LsodaDenseOutput,"Python Library Documentation: class LsodaDenseOutput in module scipy.integrate._ivp.lsoda

class LsodaDenseOutput(scipy.integrate._ivp.base.DenseOutput)
 |  Base class for local interpolant over step made by an ODE solver.
 |  
 |  It interpolates between `t_min` and `t_max` (see Attributes below).
 |  Evaluation outside this interval is not forbidden, but the accuracy is not
 |  guaranteed.
 |  
 |  Attributes
 |  ----------
 |  t_min, t_max : float
 |      Time range of the interpolation.
 |  
 |  Method resolution order:
 |      LsodaDenseOutput
 |      scipy.integrate._ivp.base.DenseOutput
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, t_old, t, h, order, yh)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.DenseOutput:
 |  
 |  __call__(self, t)
 |      Evaluate the interpolant.
 |      
 |      Parameters
 |      ----------
 |      t : float or array_like with shape (n_points,)
 |          Points to evaluate the solution at.
 |      
 |      Returns
 |      -------
 |      y : ndarray, shape (n,) or (n, n_points)
 |          Computed values. Shape depends on whether `t` was a scalar or a
 |          1-d array.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.DenseOutput:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, t_old, t, h, order, yh)',)",scipy,1.1.0,scipy.integrate._ivp.lsoda.LsodaDenseOutput,integrate._ivp.lsoda,LsodaDenseOutput,"Python Library Documentation: class LsodaDenseOutput in module scipy.integrate._ivp.lsoda

class LsodaDenseOutput(scipy.integrate._ivp.base.DenseOutput)
 |  Base class for local interpolant over step made by an ODE solver.
 |  
 |  It interpolates between `t_min` and `t_max` (see Attributes below).
 |  Evaluation outside this interval is not forbidden, but the accuracy is not
 |  guaranteed.
 |  
 |  Attributes
 |  ----------
 |  t_min, t_max : float
 |      Time range of the interpolation.
 |  
 |  Method resolution order:
 |      LsodaDenseOutput
 |      scipy.integrate._ivp.base.DenseOutput
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, t_old, t, h, order, yh)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.DenseOutput:
 |  
 |  __call__(self, t)
 |      Evaluate the interpolant.
 |      
 |      Parameters
 |      ----------
 |      t : float or array_like with shape (n_points,)
 |          Points to evaluate the solution at.
 |      
 |      Returns
 |      -------
 |      y : ndarray, shape (n,) or (n, n_points)
 |          Computed values. Shape depends on whether `t` was a scalar or a
 |          1-d array.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.DenseOutput:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 't_old', 't', 'h', 'order', 'yh')","(nan, nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, t_old, t, h, order, yh)',)"
scipy,1.1.0,scipy.integrate._ivp.lsoda.OdeSolver,integrate._ivp.lsoda,OdeSolver,"Python Library Documentation: class OdeSolver in module scipy.integrate._ivp.base

class OdeSolver(builtins.object)
 |  Base class for ODE solvers.
 |  
 |  In order to implement a new solver you need to follow the guidelines:
 |  
 |      1. A constructor must accept parameters presented in the base class
 |         (listed below) along with any other parameters specific to a solver.
 |      2. A constructor must accept arbitrary extraneous arguments
 |         ``**extraneous``, but warn that these arguments are irrelevant
 |         using `common.warn_extraneous` function. Do not pass these
 |         arguments to the base class.
 |      3. A solver must implement a private method `_step_impl(self)` which
 |         propagates a solver one step further. It must return tuple
 |         ``(success, message)``, where ``success`` is a boolean indicating
 |         whether a step was successful, and ``message`` is a string
 |         containing description of a failure if a step failed or None
 |         otherwise.
 |      4. A solver must implement a private method `_dense_output_impl(self)`
 |         which returns a `DenseOutput` object covering the last successful
 |         step.
 |      5. A solver must have attributes listed below in Attributes section.
 |         Note that `t_old` and `step_size` are updated automatically.
 |      6. Use `fun(self, t, y)` method for the system rhs evaluation, this
 |         way the number of function evaluations (`nfev`) will be tracked
 |         automatically.
 |      7. For convenience a base class provides `fun_single(self, t, y)` and
 |         `fun_vectorized(self, t, y)` for evaluating the rhs in
 |         non-vectorized and vectorized fashions respectively (regardless of
 |         how `fun` from the constructor is implemented). These calls don't
 |         increment `nfev`.
 |      8. If a solver uses a Jacobian matrix and LU decompositions, it should
 |         track the number of Jacobian evaluations (`njev`) and the number of
 |         LU decompositions (`nlu`).
 |      9. By convention the function evaluations used to compute a finite
 |         difference approximation of the Jacobian should not be counted in
 |         `nfev`, thus use `fun_single(self, t, y)` or
 |         `fun_vectorized(self, t, y)` when computing a finite difference
 |         approximation of the Jacobian.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar and there are two options for ndarray ``y``.
 |      It can either have shape (n,), then ``fun`` must return array_like with
 |      shape (n,). Or alternatively it can have shape (n, n_points), then
 |      ``fun`` must return array_like with shape (n, n_points) (each column
 |      corresponds to a single column in ``y``). The choice between the two
 |      options is determined by `vectorized` argument (see below).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time --- the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  vectorized : bool
 |      Whether `fun` is implemented in a vectorized fashion.
 |  support_complex : bool, optional
 |      Whether integration in a complex domain should be supported.
 |      Generally determined by a derived solver class capabilities.
 |      Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number of the system's rhs evaluations.
 |  njev : int
 |      Number of the Jacobian evaluations.
 |  nlu : int
 |      Number of LU decompositions.
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, vectorized, support_complex=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('(self, fun, t0, y0, t_bound, vectorized, support_complex=False)',)",scipy,1.1.0,scipy.integrate._ivp.lsoda.OdeSolver,integrate._ivp.lsoda,OdeSolver,"Python Library Documentation: class OdeSolver in module scipy.integrate._ivp.base

class OdeSolver(builtins.object)
 |  Base class for ODE solvers.
 |  
 |  In order to implement a new solver you need to follow the guidelines:
 |  
 |      1. A constructor must accept parameters presented in the base class
 |         (listed below) along with any other parameters specific to a solver.
 |      2. A constructor must accept arbitrary extraneous arguments
 |         ``**extraneous``, but warn that these arguments are irrelevant
 |         using `common.warn_extraneous` function. Do not pass these
 |         arguments to the base class.
 |      3. A solver must implement a private method `_step_impl(self)` which
 |         propagates a solver one step further. It must return tuple
 |         ``(success, message)``, where ``success`` is a boolean indicating
 |         whether a step was successful, and ``message`` is a string
 |         containing description of a failure if a step failed or None
 |         otherwise.
 |      4. A solver must implement a private method `_dense_output_impl(self)`
 |         which returns a `DenseOutput` object covering the last successful
 |         step.
 |      5. A solver must have attributes listed below in Attributes section.
 |         Note that `t_old` and `step_size` are updated automatically.
 |      6. Use `fun(self, t, y)` method for the system rhs evaluation, this
 |         way the number of function evaluations (`nfev`) will be tracked
 |         automatically.
 |      7. For convenience a base class provides `fun_single(self, t, y)` and
 |         `fun_vectorized(self, t, y)` for evaluating the rhs in
 |         non-vectorized and vectorized fashions respectively (regardless of
 |         how `fun` from the constructor is implemented). These calls don't
 |         increment `nfev`.
 |      8. If a solver uses a Jacobian matrix and LU decompositions, it should
 |         track the number of Jacobian evaluations (`njev`) and the number of
 |         LU decompositions (`nlu`).
 |      9. By convention the function evaluations used to compute a finite
 |         difference approximation of the Jacobian should not be counted in
 |         `nfev`, thus use `fun_single(self, t, y)` or
 |         `fun_vectorized(self, t, y)` when computing a finite difference
 |         approximation of the Jacobian.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar and there are two options for ndarray ``y``.
 |      It can either have shape (n,), then ``fun`` must return array_like with
 |      shape (n,). Or alternatively it can have shape (n, n_points), then
 |      ``fun`` must return array_like with shape (n, n_points) (each column
 |      corresponds to a single column in ``y``). The choice between the two
 |      options is determined by `vectorized` argument (see below).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time --- the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  vectorized : bool
 |      Whether `fun` is implemented in a vectorized fashion.
 |  support_complex : bool, optional
 |      Whether integration in a complex domain should be supported.
 |      Generally determined by a derived solver class capabilities.
 |      Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number of the system's rhs evaluations.
 |  njev : int
 |      Number of the Jacobian evaluations.
 |  nlu : int
 |      Number of LU decompositions.
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, vectorized, support_complex=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('self', 'fun', 't0', 'y0', 't_bound', 'vectorized', 'support_complex')","(nan, nan, nan, nan, nan, nan, False)","(nan, nan, nan, nan, nan, nan, 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, fun, t0, y0, t_bound, vectorized, support_complex=False)',)"
scipy,1.1.0,scipy.integrate._ivp.lsoda.ode,integrate._ivp.lsoda,ode,"Python Library Documentation: class ode in module scipy.integrate._ode

class ode(builtins.object)
 |  A generic interface class to numeric integrators.
 |  
 |  Solve an equation system :math:`y'(t) = f(t,y)` with (optional) ``jac = df/dy``.
 |  
 |  *Note*: The first two arguments of ``f(t, y, ...)`` are in the
 |  opposite order of the arguments in the system definition function used
 |  by `scipy.integrate.odeint`.
 |  
 |  Parameters
 |  ----------
 |  f : callable ``f(t, y, *f_args)``
 |      Right-hand side of the differential equation. t is a scalar,
 |      ``y.shape == (n,)``.
 |      ``f_args`` is set by calling ``set_f_params(*args)``.
 |      `f` should return a scalar, array or list (not a tuple).
 |  jac : callable ``jac(t, y, *jac_args)``, optional
 |      Jacobian of the right-hand side, ``jac[i,j] = d f[i] / d y[j]``.
 |      ``jac_args`` is set by calling ``set_jac_params(*args)``.
 |  
 |  Attributes
 |  ----------
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current variable values.
 |  
 |  See also
 |  --------
 |  odeint : an integrator with a simpler interface based on lsoda from ODEPACK
 |  quad : for finding the area under a curve
 |  
 |  Notes
 |  -----
 |  Available integrators are listed below. They can be selected using
 |  the `set_integrator` method.
 |  
 |  ""vode""
 |  
 |      Real-valued Variable-coefficient Ordinary Differential Equation
 |      solver, with fixed-leading-coefficient implementation. It provides
 |      implicit Adams method (for non-stiff problems) and a method based on
 |      backward differentiation formulas (BDF) (for stiff problems).
 |  
 |      Source: http://www.netlib.org/ode/vode.f
 |  
 |      .. warning::
 |  
 |         This integrator is not re-entrant. You cannot have two `ode`
 |         instances using the ""vode"" integrator at the same time.
 |  
 |      This integrator accepts the following parameters in `set_integrator`
 |      method of the `ode` class:
 |  
 |      - atol : float or sequence
 |        absolute tolerance for solution
 |      - rtol : float or sequence
 |        relative tolerance for solution
 |      - lband : None or int
 |      - uband : None or int
 |        Jacobian band width, jac[i,j] != 0 for i-lband <= j <= i+uband.
 |        Setting these requires your jac routine to return the jacobian
 |        in packed format, jac_packed[i-j+uband, j] = jac[i,j]. The
 |        dimension of the matrix must be (lband+uband+1, len(y)).
 |      - method: 'adams' or 'bdf'
 |        Which solver to use, Adams (non-stiff) or BDF (stiff)
 |      - with_jacobian : bool
 |        This option is only considered when the user has not supplied a
 |        Jacobian function and has not indicated (by setting either band)
 |        that the Jacobian is banded.  In this case, `with_jacobian` specifies
 |        whether the iteration method of the ODE solver's correction step is
 |        chord iteration with an internally generated full Jacobian or
 |        functional iteration with no Jacobian.
 |      - nsteps : int
 |        Maximum number of (internally defined) steps allowed during one
 |        call to the solver.
 |      - first_step : float
 |      - min_step : float
 |      - max_step : float
 |        Limits for the step sizes used by the integrator.
 |      - order : int
 |        Maximum order used by the integrator,
 |        order <= 12 for Adams, <= 5 for BDF.
 |  
 |  ""zvode""
 |  
 |      Complex-valued Variable-coefficient Ordinary Differential Equation
 |      solver, with fixed-leading-coefficient implementation.  It provides
 |      implicit Adams method (for non-stiff problems) and a method based on
 |      backward differentiation formulas (BDF) (for stiff problems).
 |  
 |      Source: http://www.netlib.org/ode/zvode.f
 |  
 |      .. warning::
 |  
 |         This integrator is not re-entrant. You cannot have two `ode`
 |         instances using the ""zvode"" integrator at the same time.
 |  
 |      This integrator accepts the same parameters in `set_integrator`
 |      as the ""vode"" solver.
 |  
 |      .. note::
 |  
 |          When using ZVODE for a stiff system, it should only be used for
 |          the case in which the function f is analytic, that is, when each f(i)
 |          is an analytic function of each y(j).  Analyticity means that the
 |          partial derivative df(i)/dy(j) is a unique complex number, and this
 |          fact is critical in the way ZVODE solves the dense or banded linear
 |          systems that arise in the stiff case.  For a complex stiff ODE system
 |          in which f is not analytic, ZVODE is likely to have convergence
 |          failures, and for this problem one should instead use DVODE on the
 |          equivalent real system (in the real and imaginary parts of y).
 |  
 |  ""lsoda""
 |  
 |      Real-valued Variable-coefficient Ordinary Differential Equation
 |      solver, with fixed-leading-coefficient implementation. It provides
 |      automatic method switching between implicit Adams method (for non-stiff
 |      problems) and a method based on backward differentiation formulas (BDF)
 |      (for stiff problems).
 |  
 |      Source: http://www.netlib.org/odepack
 |  
 |      .. warning::
 |  
 |         This integrator is not re-entrant. You cannot have two `ode`
 |         instances using the ""lsoda"" integrator at the same time.
 |  
 |      This integrator accepts the following parameters in `set_integrator`
 |      method of the `ode` class:
 |  
 |      - atol : float or sequence
 |        absolute tolerance for solution
 |      - rtol : float or sequence
 |        relative tolerance for solution
 |      - lband : None or int
 |      - uband : None or int
 |        Jacobian band width, jac[i,j] != 0 for i-lband <= j <= i+uband.
 |        Setting these requires your jac routine to return the jacobian
 |        in packed format, jac_packed[i-j+uband, j] = jac[i,j].
 |      - with_jacobian : bool
 |        *Not used.*
 |      - nsteps : int
 |        Maximum number of (internally defined) steps allowed during one
 |        call to the solver.
 |      - first_step : float
 |      - min_step : float
 |      - max_step : float
 |        Limits for the step sizes used by the integrator.
 |      - max_order_ns : int
 |        Maximum order used in the nonstiff case (default 12).
 |      - max_order_s : int
 |        Maximum order used in the stiff case (default 5).
 |      - max_hnil : int
 |        Maximum number of messages reporting too small step size (t + h = t)
 |        (default 0)
 |      - ixpr : int
 |        Whether to generate extra printing at method switches (default False).
 |  
 |  ""dopri5""
 |  
 |      This is an explicit runge-kutta method of order (4)5 due to Dormand &
 |      Prince (with stepsize control and dense output).
 |  
 |      Authors:
 |  
 |          E. Hairer and G. Wanner
 |          Universite de Geneve, Dept. de Mathematiques
 |          CH-1211 Geneve 24, Switzerland
 |          e-mail:  ernst.hairer@math.unige.ch, gerhard.wanner@math.unige.ch
 |  
 |      This code is described in [HNW93]_.
 |  
 |      This integrator accepts the following parameters in set_integrator()
 |      method of the ode class:
 |  
 |      - atol : float or sequence
 |        absolute tolerance for solution
 |      - rtol : float or sequence
 |        relative tolerance for solution
 |      - nsteps : int
 |        Maximum number of (internally defined) steps allowed during one
 |        call to the solver.
 |      - first_step : float
 |      - max_step : float
 |      - safety : float
 |        Safety factor on new step selection (default 0.9)
 |      - ifactor : float
 |      - dfactor : float
 |        Maximum factor to increase/decrease step size by in one step
 |      - beta : float
 |        Beta parameter for stabilised step size control.
 |      - verbosity : int
 |        Switch for printing messages (< 0 for no messages).
 |  
 |  ""dop853""
 |  
 |      This is an explicit runge-kutta method of order 8(5,3) due to Dormand
 |      & Prince (with stepsize control and dense output).
 |  
 |      Options and references the same as ""dopri5"".
 |  
 |  Examples
 |  --------
 |  
 |  A problem to integrate and the corresponding jacobian:
 |  
 |  >>> from scipy.integrate import ode
 |  >>>
 |  >>> y0, t0 = [1.0j, 2.0], 0
 |  >>>
 |  >>> def f(t, y, arg1):
 |  ...     return [1j*arg1*y[0] + y[1], -arg1*y[1]**2]
 |  >>> def jac(t, y, arg1):
 |  ...     return [[1j*arg1, 1], [0, -arg1*2*y[1]]]
 |  
 |  The integration:
 |  
 |  >>> r = ode(f, jac).set_integrator('zvode', method='bdf')
 |  >>> r.set_initial_value(y0, t0).set_f_params(2.0).set_jac_params(2.0)
 |  >>> t1 = 10
 |  >>> dt = 1
 |  >>> while r.successful() and r.t < t1:
 |  ...     print(r.t+dt, r.integrate(r.t+dt))
 |  1 [-0.71038232+0.23749653j  0.40000271+0.j        ]
 |  2.0 [0.19098503-0.52359246j 0.22222356+0.j        ]
 |  3.0 [0.47153208+0.52701229j 0.15384681+0.j        ]
 |  4.0 [-0.61905937+0.30726255j  0.11764744+0.j        ]
 |  5.0 [0.02340997-0.61418799j 0.09523835+0.j        ]
 |  6.0 [0.58643071+0.339819j 0.08000018+0.j      ]
 |  7.0 [-0.52070105+0.44525141j  0.06896565+0.j        ]
 |  8.0 [-0.15986733-0.61234476j  0.06060616+0.j        ]
 |  9.0 [0.64850462+0.15048982j 0.05405414+0.j        ]
 |  10.0 [-0.38404699+0.56382299j  0.04878055+0.j        ]
 |  
 |  References
 |  ----------
 |  .. [HNW93] E. Hairer, S.P. Norsett and G. Wanner, Solving Ordinary
 |      Differential Equations i. Nonstiff Problems. 2nd edition.
 |      Springer Series in Computational Mathematics,
 |      Springer-Verlag (1993)
 |  
 |  Methods defined here:
 |  
 |  __init__(self, f, jac=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  get_return_code(self)
 |      Extracts the return code for the integration to enable better control
 |      if the integration fails.
 |      
 |      In general, a return code > 0 implies success while a return code < 0
 |      implies failure.
 |      
 |      Notes
 |      -----
 |      This section describes possible return codes and their meaning, for available
 |      integrators that can be selected by `set_integrator` method.
 |      
 |      ""vode""
 |      
 |      ===========  =======
 |      Return Code  Message
 |      ===========  =======
 |      2            Integration successful.
 |      -1           Excess work done on this call. (Perhaps wrong MF.)
 |      -2           Excess accuracy requested. (Tolerances too small.)
 |      -3           Illegal input detected. (See printed message.)
 |      -4           Repeated error test failures. (Check all input.)
 |      -5           Repeated convergence failures. (Perhaps bad Jacobian
 |                   supplied or wrong choice of MF or tolerances.)
 |      -6           Error weight became zero during problem. (Solution
 |                   component i vanished, and ATOL or ATOL(i) = 0.)
 |      ===========  =======
 |      
 |      ""zvode""
 |      
 |      ===========  =======
 |      Return Code  Message
 |      ===========  =======
 |      2            Integration successful.
 |      -1           Excess work done on this call. (Perhaps wrong MF.)
 |      -2           Excess accuracy requested. (Tolerances too small.)
 |      -3           Illegal input detected. (See printed message.)
 |      -4           Repeated error test failures. (Check all input.)
 |      -5           Repeated convergence failures. (Perhaps bad Jacobian
 |                   supplied or wrong choice of MF or tolerances.)
 |      -6           Error weight became zero during problem. (Solution
 |                   component i vanished, and ATOL or ATOL(i) = 0.)
 |      ===========  =======
 |      
 |      ""dopri5""
 |      
 |      ===========  =======
 |      Return Code  Message
 |      ===========  =======
 |      1            Integration successful.
 |      2            Integration successful (interrupted by solout).
 |      -1           Input is not consistent.
 |      -2           Larger nsteps is needed.
 |      -3           Step size becomes too small.
 |      -4           Problem is probably stiff (interrupted).
 |      ===========  =======
 |      
 |      ""dop853""
 |      
 |      ===========  =======
 |      Return Code  Message
 |      ===========  =======
 |      1            Integration successful.
 |      2            Integration successful (interrupted by solout).
 |      -1           Input is not consistent.
 |      -2           Larger nsteps is needed.
 |      -3           Step size becomes too small.
 |      -4           Problem is probably stiff (interrupted).
 |      ===========  =======
 |      
 |      ""lsoda""
 |      
 |      ===========  =======
 |      Return Code  Message
 |      ===========  =======
 |      2            Integration successful.
 |      -1           Excess work done on this call (perhaps wrong Dfun type).
 |      -2           Excess accuracy requested (tolerances too small).
 |      -3           Illegal input detected (internal error).
 |      -4           Repeated error test failures (internal error).
 |      -5           Repeated convergence failures (perhaps bad Jacobian or tolerances).
 |      -6           Error weight became zero during problem.
 |      -7           Internal workspace insufficient to finish (internal error).
 |      ===========  =======
 |  
 |  integrate(self, t, step=False, relax=False)
 |      Find y=y(t), set y as an initial condition, and return y.
 |      
 |      Parameters
 |      ----------
 |      t : float
 |          The endpoint of the integration step.
 |      step : bool
 |          If True, and if the integrator supports the step method,
 |          then perform a single integration step and return.
 |          This parameter is provided in order to expose internals of
 |          the implementation, and should not be changed from its default
 |          value in most cases.
 |      relax : bool
 |          If True and if the integrator supports the run_relax method,
 |          then integrate until t_1 >= t and return. ``relax`` is not
 |          referenced if ``step=True``.
 |          This parameter is provided in order to expose internals of
 |          the implementation, and should not be changed from its default
 |          value in most cases.
 |      
 |      Returns
 |      -------
 |      y : float
 |          The integrated value at t
 |  
 |  set_f_params(self, *args)
 |      Set extra parameters for user-supplied function f.
 |  
 |  set_initial_value(self, y, t=0.0)
 |      Set initial conditions y(t) = y.
 |  
 |  set_integrator(self, name, **integrator_params)
 |      Set integrator by name.
 |      
 |      Parameters
 |      ----------
 |      name : str
 |          Name of the integrator.
 |      integrator_params
 |          Additional parameters for the integrator.
 |  
 |  set_jac_params(self, *args)
 |      Set extra parameters for user-supplied function jac.
 |  
 |  set_solout(self, solout)
 |      Set callable to be called at every successful integration step.
 |      
 |      Parameters
 |      ----------
 |      solout : callable
 |          ``solout(t, y)`` is called at each internal integrator step,
 |          t is a scalar providing the current independent position
 |          y is the current soloution ``y.shape == (n,)``
 |          solout should return -1 to stop integration
 |          otherwise it should return None or 0
 |  
 |  successful(self)
 |      Check if integration was successful.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  y
",class,"('(self, f, jac=None)',)",scipy,1.1.0,scipy.integrate._ivp.lsoda.ode,integrate._ivp.lsoda,ode,"Python Library Documentation: class ode in module scipy.integrate._ode

class ode(builtins.object)
 |  A generic interface class to numeric integrators.
 |  
 |  Solve an equation system :math:`y'(t) = f(t,y)` with (optional) ``jac = df/dy``.
 |  
 |  *Note*: The first two arguments of ``f(t, y, ...)`` are in the
 |  opposite order of the arguments in the system definition function used
 |  by `scipy.integrate.odeint`.
 |  
 |  Parameters
 |  ----------
 |  f : callable ``f(t, y, *f_args)``
 |      Right-hand side of the differential equation. t is a scalar,
 |      ``y.shape == (n,)``.
 |      ``f_args`` is set by calling ``set_f_params(*args)``.
 |      `f` should return a scalar, array or list (not a tuple).
 |  jac : callable ``jac(t, y, *jac_args)``, optional
 |      Jacobian of the right-hand side, ``jac[i,j] = d f[i] / d y[j]``.
 |      ``jac_args`` is set by calling ``set_jac_params(*args)``.
 |  
 |  Attributes
 |  ----------
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current variable values.
 |  
 |  See also
 |  --------
 |  odeint : an integrator with a simpler interface based on lsoda from ODEPACK
 |  quad : for finding the area under a curve
 |  
 |  Notes
 |  -----
 |  Available integrators are listed below. They can be selected using
 |  the `set_integrator` method.
 |  
 |  ""vode""
 |  
 |      Real-valued Variable-coefficient Ordinary Differential Equation
 |      solver, with fixed-leading-coefficient implementation. It provides
 |      implicit Adams method (for non-stiff problems) and a method based on
 |      backward differentiation formulas (BDF) (for stiff problems).
 |  
 |      Source: http://www.netlib.org/ode/vode.f
 |  
 |      .. warning::
 |  
 |         This integrator is not re-entrant. You cannot have two `ode`
 |         instances using the ""vode"" integrator at the same time.
 |  
 |      This integrator accepts the following parameters in `set_integrator`
 |      method of the `ode` class:
 |  
 |      - atol : float or sequence
 |        absolute tolerance for solution
 |      - rtol : float or sequence
 |        relative tolerance for solution
 |      - lband : None or int
 |      - uband : None or int
 |        Jacobian band width, jac[i,j] != 0 for i-lband <= j <= i+uband.
 |        Setting these requires your jac routine to return the jacobian
 |        in packed format, jac_packed[i-j+uband, j] = jac[i,j]. The
 |        dimension of the matrix must be (lband+uband+1, len(y)).
 |      - method: 'adams' or 'bdf'
 |        Which solver to use, Adams (non-stiff) or BDF (stiff)
 |      - with_jacobian : bool
 |        This option is only considered when the user has not supplied a
 |        Jacobian function and has not indicated (by setting either band)
 |        that the Jacobian is banded.  In this case, `with_jacobian` specifies
 |        whether the iteration method of the ODE solver's correction step is
 |        chord iteration with an internally generated full Jacobian or
 |        functional iteration with no Jacobian.
 |      - nsteps : int
 |        Maximum number of (internally defined) steps allowed during one
 |        call to the solver.
 |      - first_step : float
 |      - min_step : float
 |      - max_step : float
 |        Limits for the step sizes used by the integrator.
 |      - order : int
 |        Maximum order used by the integrator,
 |        order <= 12 for Adams, <= 5 for BDF.
 |  
 |  ""zvode""
 |  
 |      Complex-valued Variable-coefficient Ordinary Differential Equation
 |      solver, with fixed-leading-coefficient implementation.  It provides
 |      implicit Adams method (for non-stiff problems) and a method based on
 |      backward differentiation formulas (BDF) (for stiff problems).
 |  
 |      Source: http://www.netlib.org/ode/zvode.f
 |  
 |      .. warning::
 |  
 |         This integrator is not re-entrant. You cannot have two `ode`
 |         instances using the ""zvode"" integrator at the same time.
 |  
 |      This integrator accepts the same parameters in `set_integrator`
 |      as the ""vode"" solver.
 |  
 |      .. note::
 |  
 |          When using ZVODE for a stiff system, it should only be used for
 |          the case in which the function f is analytic, that is, when each f(i)
 |          is an analytic function of each y(j).  Analyticity means that the
 |          partial derivative df(i)/dy(j) is a unique complex number, and this
 |          fact is critical in the way ZVODE solves the dense or banded linear
 |          systems that arise in the stiff case.  For a complex stiff ODE system
 |          in which f is not analytic, ZVODE is likely to have convergence
 |          failures, and for this problem one should instead use DVODE on the
 |          equivalent real system (in the real and imaginary parts of y).
 |  
 |  ""lsoda""
 |  
 |      Real-valued Variable-coefficient Ordinary Differential Equation
 |      solver, with fixed-leading-coefficient implementation. It provides
 |      automatic method switching between implicit Adams method (for non-stiff
 |      problems) and a method based on backward differentiation formulas (BDF)
 |      (for stiff problems).
 |  
 |      Source: http://www.netlib.org/odepack
 |  
 |      .. warning::
 |  
 |         This integrator is not re-entrant. You cannot have two `ode`
 |         instances using the ""lsoda"" integrator at the same time.
 |  
 |      This integrator accepts the following parameters in `set_integrator`
 |      method of the `ode` class:
 |  
 |      - atol : float or sequence
 |        absolute tolerance for solution
 |      - rtol : float or sequence
 |        relative tolerance for solution
 |      - lband : None or int
 |      - uband : None or int
 |        Jacobian band width, jac[i,j] != 0 for i-lband <= j <= i+uband.
 |        Setting these requires your jac routine to return the jacobian
 |        in packed format, jac_packed[i-j+uband, j] = jac[i,j].
 |      - with_jacobian : bool
 |        *Not used.*
 |      - nsteps : int
 |        Maximum number of (internally defined) steps allowed during one
 |        call to the solver.
 |      - first_step : float
 |      - min_step : float
 |      - max_step : float
 |        Limits for the step sizes used by the integrator.
 |      - max_order_ns : int
 |        Maximum order used in the nonstiff case (default 12).
 |      - max_order_s : int
 |        Maximum order used in the stiff case (default 5).
 |      - max_hnil : int
 |        Maximum number of messages reporting too small step size (t + h = t)
 |        (default 0)
 |      - ixpr : int
 |        Whether to generate extra printing at method switches (default False).
 |  
 |  ""dopri5""
 |  
 |      This is an explicit runge-kutta method of order (4)5 due to Dormand &
 |      Prince (with stepsize control and dense output).
 |  
 |      Authors:
 |  
 |          E. Hairer and G. Wanner
 |          Universite de Geneve, Dept. de Mathematiques
 |          CH-1211 Geneve 24, Switzerland
 |          e-mail:  ernst.hairer@math.unige.ch, gerhard.wanner@math.unige.ch
 |  
 |      This code is described in [HNW93]_.
 |  
 |      This integrator accepts the following parameters in set_integrator()
 |      method of the ode class:
 |  
 |      - atol : float or sequence
 |        absolute tolerance for solution
 |      - rtol : float or sequence
 |        relative tolerance for solution
 |      - nsteps : int
 |        Maximum number of (internally defined) steps allowed during one
 |        call to the solver.
 |      - first_step : float
 |      - max_step : float
 |      - safety : float
 |        Safety factor on new step selection (default 0.9)
 |      - ifactor : float
 |      - dfactor : float
 |        Maximum factor to increase/decrease step size by in one step
 |      - beta : float
 |        Beta parameter for stabilised step size control.
 |      - verbosity : int
 |        Switch for printing messages (< 0 for no messages).
 |  
 |  ""dop853""
 |  
 |      This is an explicit runge-kutta method of order 8(5,3) due to Dormand
 |      & Prince (with stepsize control and dense output).
 |  
 |      Options and references the same as ""dopri5"".
 |  
 |  Examples
 |  --------
 |  
 |  A problem to integrate and the corresponding jacobian:
 |  
 |  >>> from scipy.integrate import ode
 |  >>>
 |  >>> y0, t0 = [1.0j, 2.0], 0
 |  >>>
 |  >>> def f(t, y, arg1):
 |  ...     return [1j*arg1*y[0] + y[1], -arg1*y[1]**2]
 |  >>> def jac(t, y, arg1):
 |  ...     return [[1j*arg1, 1], [0, -arg1*2*y[1]]]
 |  
 |  The integration:
 |  
 |  >>> r = ode(f, jac).set_integrator('zvode', method='bdf')
 |  >>> r.set_initial_value(y0, t0).set_f_params(2.0).set_jac_params(2.0)
 |  >>> t1 = 10
 |  >>> dt = 1
 |  >>> while r.successful() and r.t < t1:
 |  ...     print(r.t+dt, r.integrate(r.t+dt))
 |  1 [-0.71038232+0.23749653j  0.40000271+0.j        ]
 |  2.0 [0.19098503-0.52359246j 0.22222356+0.j        ]
 |  3.0 [0.47153208+0.52701229j 0.15384681+0.j        ]
 |  4.0 [-0.61905937+0.30726255j  0.11764744+0.j        ]
 |  5.0 [0.02340997-0.61418799j 0.09523835+0.j        ]
 |  6.0 [0.58643071+0.339819j 0.08000018+0.j      ]
 |  7.0 [-0.52070105+0.44525141j  0.06896565+0.j        ]
 |  8.0 [-0.15986733-0.61234476j  0.06060616+0.j        ]
 |  9.0 [0.64850462+0.15048982j 0.05405414+0.j        ]
 |  10.0 [-0.38404699+0.56382299j  0.04878055+0.j        ]
 |  
 |  References
 |  ----------
 |  .. [HNW93] E. Hairer, S.P. Norsett and G. Wanner, Solving Ordinary
 |      Differential Equations i. Nonstiff Problems. 2nd edition.
 |      Springer Series in Computational Mathematics,
 |      Springer-Verlag (1993)
 |  
 |  Methods defined here:
 |  
 |  __init__(self, f, jac=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  get_return_code(self)
 |      Extracts the return code for the integration to enable better control
 |      if the integration fails.
 |      
 |      In general, a return code > 0 implies success while a return code < 0
 |      implies failure.
 |      
 |      Notes
 |      -----
 |      This section describes possible return codes and their meaning, for available
 |      integrators that can be selected by `set_integrator` method.
 |      
 |      ""vode""
 |      
 |      ===========  =======
 |      Return Code  Message
 |      ===========  =======
 |      2            Integration successful.
 |      -1           Excess work done on this call. (Perhaps wrong MF.)
 |      -2           Excess accuracy requested. (Tolerances too small.)
 |      -3           Illegal input detected. (See printed message.)
 |      -4           Repeated error test failures. (Check all input.)
 |      -5           Repeated convergence failures. (Perhaps bad Jacobian
 |                   supplied or wrong choice of MF or tolerances.)
 |      -6           Error weight became zero during problem. (Solution
 |                   component i vanished, and ATOL or ATOL(i) = 0.)
 |      ===========  =======
 |      
 |      ""zvode""
 |      
 |      ===========  =======
 |      Return Code  Message
 |      ===========  =======
 |      2            Integration successful.
 |      -1           Excess work done on this call. (Perhaps wrong MF.)
 |      -2           Excess accuracy requested. (Tolerances too small.)
 |      -3           Illegal input detected. (See printed message.)
 |      -4           Repeated error test failures. (Check all input.)
 |      -5           Repeated convergence failures. (Perhaps bad Jacobian
 |                   supplied or wrong choice of MF or tolerances.)
 |      -6           Error weight became zero during problem. (Solution
 |                   component i vanished, and ATOL or ATOL(i) = 0.)
 |      ===========  =======
 |      
 |      ""dopri5""
 |      
 |      ===========  =======
 |      Return Code  Message
 |      ===========  =======
 |      1            Integration successful.
 |      2            Integration successful (interrupted by solout).
 |      -1           Input is not consistent.
 |      -2           Larger nsteps is needed.
 |      -3           Step size becomes too small.
 |      -4           Problem is probably stiff (interrupted).
 |      ===========  =======
 |      
 |      ""dop853""
 |      
 |      ===========  =======
 |      Return Code  Message
 |      ===========  =======
 |      1            Integration successful.
 |      2            Integration successful (interrupted by solout).
 |      -1           Input is not consistent.
 |      -2           Larger nsteps is needed.
 |      -3           Step size becomes too small.
 |      -4           Problem is probably stiff (interrupted).
 |      ===========  =======
 |      
 |      ""lsoda""
 |      
 |      ===========  =======
 |      Return Code  Message
 |      ===========  =======
 |      2            Integration successful.
 |      -1           Excess work done on this call (perhaps wrong Dfun type).
 |      -2           Excess accuracy requested (tolerances too small).
 |      -3           Illegal input detected (internal error).
 |      -4           Repeated error test failures (internal error).
 |      -5           Repeated convergence failures (perhaps bad Jacobian or tolerances).
 |      -6           Error weight became zero during problem.
 |      -7           Internal workspace insufficient to finish (internal error).
 |      ===========  =======
 |  
 |  integrate(self, t, step=False, relax=False)
 |      Find y=y(t), set y as an initial condition, and return y.
 |      
 |      Parameters
 |      ----------
 |      t : float
 |          The endpoint of the integration step.
 |      step : bool
 |          If True, and if the integrator supports the step method,
 |          then perform a single integration step and return.
 |          This parameter is provided in order to expose internals of
 |          the implementation, and should not be changed from its default
 |          value in most cases.
 |      relax : bool
 |          If True and if the integrator supports the run_relax method,
 |          then integrate until t_1 >= t and return. ``relax`` is not
 |          referenced if ``step=True``.
 |          This parameter is provided in order to expose internals of
 |          the implementation, and should not be changed from its default
 |          value in most cases.
 |      
 |      Returns
 |      -------
 |      y : float
 |          The integrated value at t
 |  
 |  set_f_params(self, *args)
 |      Set extra parameters for user-supplied function f.
 |  
 |  set_initial_value(self, y, t=0.0)
 |      Set initial conditions y(t) = y.
 |  
 |  set_integrator(self, name, **integrator_params)
 |      Set integrator by name.
 |      
 |      Parameters
 |      ----------
 |      name : str
 |          Name of the integrator.
 |      integrator_params
 |          Additional parameters for the integrator.
 |  
 |  set_jac_params(self, *args)
 |      Set extra parameters for user-supplied function jac.
 |  
 |  set_solout(self, solout)
 |      Set callable to be called at every successful integration step.
 |      
 |      Parameters
 |      ----------
 |      solout : callable
 |          ``solout(t, y)`` is called at each internal integrator step,
 |          t is a scalar providing the current independent position
 |          y is the current soloution ``y.shape == (n,)``
 |          solout should return -1 to stop integration
 |          otherwise it should return None or 0
 |  
 |  successful(self)
 |      Check if integration was successful.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  y
",class,"('self', 'f', 'jac')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(self, f, jac=None)',)"
scipy,1.1.0,scipy.integrate._ivp.lsoda.validate_tol,integrate._ivp.lsoda,validate_tol,"Python Library Documentation: function validate_tol in module scipy.integrate._ivp.common

validate_tol(rtol, atol, n)
    Validate tolerance values.
",function,"('(rtol, atol, n)',)",scipy,1.1.0,scipy.integrate._ivp.lsoda.validate_tol,integrate._ivp.lsoda,validate_tol,"Python Library Documentation: function validate_tol in module scipy.integrate._ivp.common

validate_tol(rtol, atol, n)
    Validate tolerance values.
",function,"('rtol', 'atol', 'n')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(rtol, atol, n)',)"
scipy,1.1.0,scipy.integrate._ivp.lsoda.warn_extraneous,integrate._ivp.lsoda,warn_extraneous,"Python Library Documentation: function warn_extraneous in module scipy.integrate._ivp.common

warn_extraneous(extraneous)
    Display a warning for extraneous keyword arguments.
    
    The initializer of each solver class is expected to collect keyword
    arguments that it doesn't understand and warn about them. This function
    prints a warning for each key in the supplied dictionary.
    
    Parameters
    ----------
    extraneous : dict
        Extraneous keyword arguments
",function,"('(extraneous)',)",scipy,1.1.0,scipy.integrate._ivp.lsoda.warn_extraneous,integrate._ivp.lsoda,warn_extraneous,"Python Library Documentation: function warn_extraneous in module scipy.integrate._ivp.common

warn_extraneous(extraneous)
    Display a warning for extraneous keyword arguments.
    
    The initializer of each solver class is expected to collect keyword
    arguments that it doesn't understand and warn about them. This function
    prints a warning for each key in the supplied dictionary.
    
    Parameters
    ----------
    extraneous : dict
        Extraneous keyword arguments
",function,"('extraneous',)","(nan,)","(nan,)","('arg_info',)","('(extraneous)',)"
scipy,1.1.0,scipy.integrate._ivp.radau.DenseOutput,integrate._ivp.radau,DenseOutput,"Python Library Documentation: class DenseOutput in module scipy.integrate._ivp.base

class DenseOutput(builtins.object)
 |  Base class for local interpolant over step made by an ODE solver.
 |  
 |  It interpolates between `t_min` and `t_max` (see Attributes below).
 |  Evaluation outside this interval is not forbidden, but the accuracy is not
 |  guaranteed.
 |  
 |  Attributes
 |  ----------
 |  t_min, t_max : float
 |      Time range of the interpolation.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, t)
 |      Evaluate the interpolant.
 |      
 |      Parameters
 |      ----------
 |      t : float or array_like with shape (n_points,)
 |          Points to evaluate the solution at.
 |      
 |      Returns
 |      -------
 |      y : ndarray, shape (n,) or (n, n_points)
 |          Computed values. Shape depends on whether `t` was a scalar or a
 |          1-d array.
 |  
 |  __init__(self, t_old, t)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, t_old, t)',)",scipy,1.1.0,scipy.integrate._ivp.radau.DenseOutput,integrate._ivp.radau,DenseOutput,"Python Library Documentation: class DenseOutput in module scipy.integrate._ivp.base

class DenseOutput(builtins.object)
 |  Base class for local interpolant over step made by an ODE solver.
 |  
 |  It interpolates between `t_min` and `t_max` (see Attributes below).
 |  Evaluation outside this interval is not forbidden, but the accuracy is not
 |  guaranteed.
 |  
 |  Attributes
 |  ----------
 |  t_min, t_max : float
 |      Time range of the interpolation.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, t)
 |      Evaluate the interpolant.
 |      
 |      Parameters
 |      ----------
 |      t : float or array_like with shape (n_points,)
 |          Points to evaluate the solution at.
 |      
 |      Returns
 |      -------
 |      y : ndarray, shape (n,) or (n, n_points)
 |          Computed values. Shape depends on whether `t` was a scalar or a
 |          1-d array.
 |  
 |  __init__(self, t_old, t)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 't_old', 't')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(self, t_old, t)',)"
scipy,1.1.0,scipy.integrate._ivp.radau.OdeSolver,integrate._ivp.radau,OdeSolver,"Python Library Documentation: class OdeSolver in module scipy.integrate._ivp.base

class OdeSolver(builtins.object)
 |  Base class for ODE solvers.
 |  
 |  In order to implement a new solver you need to follow the guidelines:
 |  
 |      1. A constructor must accept parameters presented in the base class
 |         (listed below) along with any other parameters specific to a solver.
 |      2. A constructor must accept arbitrary extraneous arguments
 |         ``**extraneous``, but warn that these arguments are irrelevant
 |         using `common.warn_extraneous` function. Do not pass these
 |         arguments to the base class.
 |      3. A solver must implement a private method `_step_impl(self)` which
 |         propagates a solver one step further. It must return tuple
 |         ``(success, message)``, where ``success`` is a boolean indicating
 |         whether a step was successful, and ``message`` is a string
 |         containing description of a failure if a step failed or None
 |         otherwise.
 |      4. A solver must implement a private method `_dense_output_impl(self)`
 |         which returns a `DenseOutput` object covering the last successful
 |         step.
 |      5. A solver must have attributes listed below in Attributes section.
 |         Note that `t_old` and `step_size` are updated automatically.
 |      6. Use `fun(self, t, y)` method for the system rhs evaluation, this
 |         way the number of function evaluations (`nfev`) will be tracked
 |         automatically.
 |      7. For convenience a base class provides `fun_single(self, t, y)` and
 |         `fun_vectorized(self, t, y)` for evaluating the rhs in
 |         non-vectorized and vectorized fashions respectively (regardless of
 |         how `fun` from the constructor is implemented). These calls don't
 |         increment `nfev`.
 |      8. If a solver uses a Jacobian matrix and LU decompositions, it should
 |         track the number of Jacobian evaluations (`njev`) and the number of
 |         LU decompositions (`nlu`).
 |      9. By convention the function evaluations used to compute a finite
 |         difference approximation of the Jacobian should not be counted in
 |         `nfev`, thus use `fun_single(self, t, y)` or
 |         `fun_vectorized(self, t, y)` when computing a finite difference
 |         approximation of the Jacobian.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar and there are two options for ndarray ``y``.
 |      It can either have shape (n,), then ``fun`` must return array_like with
 |      shape (n,). Or alternatively it can have shape (n, n_points), then
 |      ``fun`` must return array_like with shape (n, n_points) (each column
 |      corresponds to a single column in ``y``). The choice between the two
 |      options is determined by `vectorized` argument (see below).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time --- the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  vectorized : bool
 |      Whether `fun` is implemented in a vectorized fashion.
 |  support_complex : bool, optional
 |      Whether integration in a complex domain should be supported.
 |      Generally determined by a derived solver class capabilities.
 |      Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number of the system's rhs evaluations.
 |  njev : int
 |      Number of the Jacobian evaluations.
 |  nlu : int
 |      Number of LU decompositions.
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, vectorized, support_complex=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('(self, fun, t0, y0, t_bound, vectorized, support_complex=False)',)",scipy,1.1.0,scipy.integrate._ivp.radau.OdeSolver,integrate._ivp.radau,OdeSolver,"Python Library Documentation: class OdeSolver in module scipy.integrate._ivp.base

class OdeSolver(builtins.object)
 |  Base class for ODE solvers.
 |  
 |  In order to implement a new solver you need to follow the guidelines:
 |  
 |      1. A constructor must accept parameters presented in the base class
 |         (listed below) along with any other parameters specific to a solver.
 |      2. A constructor must accept arbitrary extraneous arguments
 |         ``**extraneous``, but warn that these arguments are irrelevant
 |         using `common.warn_extraneous` function. Do not pass these
 |         arguments to the base class.
 |      3. A solver must implement a private method `_step_impl(self)` which
 |         propagates a solver one step further. It must return tuple
 |         ``(success, message)``, where ``success`` is a boolean indicating
 |         whether a step was successful, and ``message`` is a string
 |         containing description of a failure if a step failed or None
 |         otherwise.
 |      4. A solver must implement a private method `_dense_output_impl(self)`
 |         which returns a `DenseOutput` object covering the last successful
 |         step.
 |      5. A solver must have attributes listed below in Attributes section.
 |         Note that `t_old` and `step_size` are updated automatically.
 |      6. Use `fun(self, t, y)` method for the system rhs evaluation, this
 |         way the number of function evaluations (`nfev`) will be tracked
 |         automatically.
 |      7. For convenience a base class provides `fun_single(self, t, y)` and
 |         `fun_vectorized(self, t, y)` for evaluating the rhs in
 |         non-vectorized and vectorized fashions respectively (regardless of
 |         how `fun` from the constructor is implemented). These calls don't
 |         increment `nfev`.
 |      8. If a solver uses a Jacobian matrix and LU decompositions, it should
 |         track the number of Jacobian evaluations (`njev`) and the number of
 |         LU decompositions (`nlu`).
 |      9. By convention the function evaluations used to compute a finite
 |         difference approximation of the Jacobian should not be counted in
 |         `nfev`, thus use `fun_single(self, t, y)` or
 |         `fun_vectorized(self, t, y)` when computing a finite difference
 |         approximation of the Jacobian.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar and there are two options for ndarray ``y``.
 |      It can either have shape (n,), then ``fun`` must return array_like with
 |      shape (n,). Or alternatively it can have shape (n, n_points), then
 |      ``fun`` must return array_like with shape (n, n_points) (each column
 |      corresponds to a single column in ``y``). The choice between the two
 |      options is determined by `vectorized` argument (see below).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time --- the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  vectorized : bool
 |      Whether `fun` is implemented in a vectorized fashion.
 |  support_complex : bool, optional
 |      Whether integration in a complex domain should be supported.
 |      Generally determined by a derived solver class capabilities.
 |      Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number of the system's rhs evaluations.
 |  njev : int
 |      Number of the Jacobian evaluations.
 |  nlu : int
 |      Number of LU decompositions.
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, vectorized, support_complex=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('self', 'fun', 't0', 'y0', 't_bound', 'vectorized', 'support_complex')","(nan, nan, nan, nan, nan, nan, False)","(nan, nan, nan, nan, nan, nan, 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, fun, t0, y0, t_bound, vectorized, support_complex=False)',)"
scipy,1.1.0,scipy.integrate._ivp.radau.Radau,integrate._ivp.radau,Radau,"Python Library Documentation: class Radau in module scipy.integrate._ivp.radau

class Radau(scipy.integrate._ivp.base.OdeSolver)
 |  Implicit Runge-Kutta method of Radau IIA family of order 5.
 |  
 |  The implementation follows [1]_. The error is controlled with a
 |  third-order accurate embedded formula. A cubic polynomial which satisfies
 |  the collocation conditions is used for the dense output.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar, and there are two options for the ndarray ``y``:
 |      It can either have shape (n,); then ``fun`` must return array_like with
 |      shape (n,). Alternatively it can have shape (n, k); then ``fun``
 |      must return an array_like with shape (n, k), i.e. each column
 |      corresponds to a single column in ``y``. The choice between the two
 |      options is determined by `vectorized` argument (see below). The
 |      vectorized implementation allows a faster approximation of the Jacobian
 |      by finite differences (required for this solver).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time - the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  max_step : float, optional
 |      Maximum allowed step size. Default is np.inf, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  rtol, atol : float and array_like, optional
 |      Relative and absolute tolerances. The solver keeps the local error
 |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
 |      relative accuracy (number of correct digits). But if a component of `y`
 |      is approximately below `atol`, the error only needs to fall within
 |      the same `atol` threshold, and the number of correct digits is not
 |      guaranteed. If components of y have different scales, it might be
 |      beneficial to set different `atol` values for different components by
 |      passing array_like with shape (n,) for `atol`. Default values are
 |      1e-3 for `rtol` and 1e-6 for `atol`.
 |  jac : {None, array_like, sparse_matrix, callable}, optional
 |      Jacobian matrix of the right-hand side of the system with respect to
 |      y, required by this method. The Jacobian matrix has shape (n, n) and
 |      its element (i, j) is equal to ``d f_i / d y_j``.
 |      There are three ways to define the Jacobian:
 |  
 |          * If array_like or sparse_matrix, the Jacobian is assumed to
 |            be constant.
 |          * If callable, the Jacobian is assumed to depend on both
 |            t and y; it will be called as ``jac(t, y)`` as necessary.
 |            For the 'Radau' and 'BDF' methods, the return value might be a
 |            sparse matrix.
 |          * If None (default), the Jacobian will be approximated by
 |            finite differences.
 |  
 |      It is generally recommended to provide the Jacobian rather than
 |      relying on a finite-difference approximation.
 |  jac_sparsity : {None, array_like, sparse matrix}, optional
 |      Defines a sparsity structure of the Jacobian matrix for a
 |      finite-difference approximation. Its shape must be (n, n). This argument
 |      is ignored if `jac` is not `None`. If the Jacobian has only few non-zero
 |      elements in *each* row, providing the sparsity structure will greatly
 |      speed up the computations [2]_. A zero entry means that a corresponding
 |      element in the Jacobian is always zero. If None (default), the Jacobian
 |      is assumed to be dense.
 |  vectorized : bool, optional
 |      Whether `fun` is implemented in a vectorized fashion. Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number of evaluations of the right-hand side.
 |  njev : int
 |      Number of evaluations of the Jacobian.
 |  nlu : int
 |      Number of LU decompositions.
 |  
 |  References
 |  ----------
 |  .. [1] E. Hairer, G. Wanner, ""Solving Ordinary Differential Equations II:
 |         Stiff and Differential-Algebraic Problems"", Sec. IV.8.
 |  .. [2] A. Curtis, M. J. D. Powell, and J. Reid, ""On the estimation of
 |         sparse Jacobian matrices"", Journal of the Institute of Mathematics
 |         and its Applications, 13, pp. 117-120, 1974.
 |  
 |  Method resolution order:
 |      Radau
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, jac=None, jac_sparsity=None, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, jac=None, jac_sparsity=None, vectorized=False, **extraneous)',)",scipy,1.1.0,scipy.integrate._ivp.radau.Radau,integrate._ivp.radau,Radau,"Python Library Documentation: class Radau in module scipy.integrate._ivp.radau

class Radau(scipy.integrate._ivp.base.OdeSolver)
 |  Implicit Runge-Kutta method of Radau IIA family of order 5.
 |  
 |  The implementation follows [1]_. The error is controlled with a
 |  third-order accurate embedded formula. A cubic polynomial which satisfies
 |  the collocation conditions is used for the dense output.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar, and there are two options for the ndarray ``y``:
 |      It can either have shape (n,); then ``fun`` must return array_like with
 |      shape (n,). Alternatively it can have shape (n, k); then ``fun``
 |      must return an array_like with shape (n, k), i.e. each column
 |      corresponds to a single column in ``y``. The choice between the two
 |      options is determined by `vectorized` argument (see below). The
 |      vectorized implementation allows a faster approximation of the Jacobian
 |      by finite differences (required for this solver).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time - the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  max_step : float, optional
 |      Maximum allowed step size. Default is np.inf, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  rtol, atol : float and array_like, optional
 |      Relative and absolute tolerances. The solver keeps the local error
 |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
 |      relative accuracy (number of correct digits). But if a component of `y`
 |      is approximately below `atol`, the error only needs to fall within
 |      the same `atol` threshold, and the number of correct digits is not
 |      guaranteed. If components of y have different scales, it might be
 |      beneficial to set different `atol` values for different components by
 |      passing array_like with shape (n,) for `atol`. Default values are
 |      1e-3 for `rtol` and 1e-6 for `atol`.
 |  jac : {None, array_like, sparse_matrix, callable}, optional
 |      Jacobian matrix of the right-hand side of the system with respect to
 |      y, required by this method. The Jacobian matrix has shape (n, n) and
 |      its element (i, j) is equal to ``d f_i / d y_j``.
 |      There are three ways to define the Jacobian:
 |  
 |          * If array_like or sparse_matrix, the Jacobian is assumed to
 |            be constant.
 |          * If callable, the Jacobian is assumed to depend on both
 |            t and y; it will be called as ``jac(t, y)`` as necessary.
 |            For the 'Radau' and 'BDF' methods, the return value might be a
 |            sparse matrix.
 |          * If None (default), the Jacobian will be approximated by
 |            finite differences.
 |  
 |      It is generally recommended to provide the Jacobian rather than
 |      relying on a finite-difference approximation.
 |  jac_sparsity : {None, array_like, sparse matrix}, optional
 |      Defines a sparsity structure of the Jacobian matrix for a
 |      finite-difference approximation. Its shape must be (n, n). This argument
 |      is ignored if `jac` is not `None`. If the Jacobian has only few non-zero
 |      elements in *each* row, providing the sparsity structure will greatly
 |      speed up the computations [2]_. A zero entry means that a corresponding
 |      element in the Jacobian is always zero. If None (default), the Jacobian
 |      is assumed to be dense.
 |  vectorized : bool, optional
 |      Whether `fun` is implemented in a vectorized fashion. Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number of evaluations of the right-hand side.
 |  njev : int
 |      Number of evaluations of the Jacobian.
 |  nlu : int
 |      Number of LU decompositions.
 |  
 |  References
 |  ----------
 |  .. [1] E. Hairer, G. Wanner, ""Solving Ordinary Differential Equations II:
 |         Stiff and Differential-Algebraic Problems"", Sec. IV.8.
 |  .. [2] A. Curtis, M. J. D. Powell, and J. Reid, ""On the estimation of
 |         sparse Jacobian matrices"", Journal of the Institute of Mathematics
 |         and its Applications, 13, pp. 117-120, 1974.
 |  
 |  Method resolution order:
 |      Radau
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, jac=None, jac_sparsity=None, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('self', 'fun', 't0', 'y0', 't_bound', 'max_step', 'rtol', 'atol', 'jac', 'jac_sparsity', 'vectorized')","(nan, nan, nan, nan, nan, inf, 0.001, 1e-06, None, None, False)","(nan, nan, nan, nan, nan, 'float', 'float', 'float', 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, jac=None, jac_sparsity=None, vectorized=False, **extraneous)',)"
scipy,1.1.0,scipy.integrate._ivp.radau.RadauDenseOutput,integrate._ivp.radau,RadauDenseOutput,"Python Library Documentation: class RadauDenseOutput in module scipy.integrate._ivp.radau

class RadauDenseOutput(scipy.integrate._ivp.base.DenseOutput)
 |  Base class for local interpolant over step made by an ODE solver.
 |  
 |  It interpolates between `t_min` and `t_max` (see Attributes below).
 |  Evaluation outside this interval is not forbidden, but the accuracy is not
 |  guaranteed.
 |  
 |  Attributes
 |  ----------
 |  t_min, t_max : float
 |      Time range of the interpolation.
 |  
 |  Method resolution order:
 |      RadauDenseOutput
 |      scipy.integrate._ivp.base.DenseOutput
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, t_old, t, y_old, Q)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.DenseOutput:
 |  
 |  __call__(self, t)
 |      Evaluate the interpolant.
 |      
 |      Parameters
 |      ----------
 |      t : float or array_like with shape (n_points,)
 |          Points to evaluate the solution at.
 |      
 |      Returns
 |      -------
 |      y : ndarray, shape (n,) or (n, n_points)
 |          Computed values. Shape depends on whether `t` was a scalar or a
 |          1-d array.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.DenseOutput:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, t_old, t, y_old, Q)',)",scipy,1.1.0,scipy.integrate._ivp.radau.RadauDenseOutput,integrate._ivp.radau,RadauDenseOutput,"Python Library Documentation: class RadauDenseOutput in module scipy.integrate._ivp.radau

class RadauDenseOutput(scipy.integrate._ivp.base.DenseOutput)
 |  Base class for local interpolant over step made by an ODE solver.
 |  
 |  It interpolates between `t_min` and `t_max` (see Attributes below).
 |  Evaluation outside this interval is not forbidden, but the accuracy is not
 |  guaranteed.
 |  
 |  Attributes
 |  ----------
 |  t_min, t_max : float
 |      Time range of the interpolation.
 |  
 |  Method resolution order:
 |      RadauDenseOutput
 |      scipy.integrate._ivp.base.DenseOutput
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, t_old, t, y_old, Q)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.DenseOutput:
 |  
 |  __call__(self, t)
 |      Evaluate the interpolant.
 |      
 |      Parameters
 |      ----------
 |      t : float or array_like with shape (n_points,)
 |          Points to evaluate the solution at.
 |      
 |      Returns
 |      -------
 |      y : ndarray, shape (n,) or (n, n_points)
 |          Computed values. Shape depends on whether `t` was a scalar or a
 |          1-d array.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.DenseOutput:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 't_old', 't', 'y_old', 'Q')","(nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, t_old, t, y_old, Q)',)"
scipy,1.1.0,scipy.integrate._ivp.radau.csc_matrix,integrate._ivp.radau,csc_matrix,"Python Library Documentation: class csc_matrix in module scipy.sparse.csc

class csc_matrix(scipy.sparse.compressed._cs_matrix, scipy.sparse.sputils.IndexMixin)
 |  Compressed Sparse Column matrix
 |  
 |  This can be instantiated in several ways:
 |  
 |      csc_matrix(D)
 |          with a dense matrix or rank-2 ndarray D
 |  
 |      csc_matrix(S)
 |          with another sparse matrix S (equivalent to S.tocsc())
 |  
 |      csc_matrix((M, N), [dtype])
 |          to construct an empty matrix with shape (M, N)
 |          dtype is optional, defaulting to dtype='d'.
 |  
 |      csc_matrix((data, (row_ind, col_ind)), [shape=(M, N)])
 |          where ``data``, ``row_ind`` and ``col_ind`` satisfy the
 |          relationship ``a[row_ind[k], col_ind[k]] = data[k]``.
 |  
 |      csc_matrix((data, indices, indptr), [shape=(M, N)])
 |          is the standard CSC representation where the row indices for
 |          column i are stored in ``indices[indptr[i]:indptr[i+1]]``
 |          and their corresponding values are stored in
 |          ``data[indptr[i]:indptr[i+1]]``.  If the shape parameter is
 |          not supplied, the matrix dimensions are inferred from
 |          the index arrays.
 |  
 |  Attributes
 |  ----------
 |  dtype : dtype
 |      Data type of the matrix
 |  shape : 2-tuple
 |      Shape of the matrix
 |  ndim : int
 |      Number of dimensions (this is always 2)
 |  nnz
 |      Number of nonzero elements
 |  data
 |      Data array of the matrix
 |  indices
 |      CSC format index array
 |  indptr
 |      CSC format index pointer array
 |  has_sorted_indices
 |      Whether indices are sorted
 |  
 |  Notes
 |  -----
 |  
 |  Sparse matrices can be used in arithmetic operations: they support
 |  addition, subtraction, multiplication, division, and matrix power.
 |  
 |  Advantages of the CSC format
 |      - efficient arithmetic operations CSC + CSC, CSC * CSC, etc.
 |      - efficient column slicing
 |      - fast matrix vector products (CSR, BSR may be faster)
 |  
 |  Disadvantages of the CSC format
 |    - slow row slicing operations (consider CSR)
 |    - changes to the sparsity structure are expensive (consider LIL or DOK)
 |  
 |  
 |  Examples
 |  --------
 |  
 |  >>> import numpy as np
 |  >>> from scipy.sparse import csc_matrix
 |  >>> csc_matrix((3, 4), dtype=np.int8).toarray()
 |  array([[0, 0, 0, 0],
 |         [0, 0, 0, 0],
 |         [0, 0, 0, 0]], dtype=int8)
 |  
 |  >>> row = np.array([0, 2, 2, 0, 1, 2])
 |  >>> col = np.array([0, 0, 1, 2, 2, 2])
 |  >>> data = np.array([1, 2, 3, 4, 5, 6])
 |  >>> csc_matrix((data, (row, col)), shape=(3, 3)).toarray()
 |  array([[1, 0, 4],
 |         [0, 0, 5],
 |         [2, 3, 6]])
 |  
 |  >>> indptr = np.array([0, 2, 3, 6])
 |  >>> indices = np.array([0, 2, 2, 0, 1, 2])
 |  >>> data = np.array([1, 2, 3, 4, 5, 6])
 |  >>> csc_matrix((data, indices, indptr), shape=(3, 3)).toarray()
 |  array([[1, 0, 4],
 |         [0, 0, 5],
 |         [2, 3, 6]])
 |  
 |  Method resolution order:
 |      csc_matrix
 |      scipy.sparse.compressed._cs_matrix
 |      scipy.sparse.data._data_matrix
 |      scipy.sparse.base.spmatrix
 |      scipy.sparse.data._minmax_mixin
 |      scipy.sparse.sputils.IndexMixin
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __getitem__(self, key)
 |  
 |  __iter__(self)
 |  
 |  getcol(self, i)
 |      Returns a copy of column i of the matrix, as a (m x 1)
 |      CSC matrix (column vector).
 |  
 |  getrow(self, i)
 |      Returns a copy of row i of the matrix, as a (1 x n)
 |      CSR matrix (row vector).
 |  
 |  nonzero(self)
 |      nonzero indices
 |      
 |      Returns a tuple of arrays (row,col) containing the indices
 |      of the non-zero elements of the matrix.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1,2,0],[0,0,3],[4,0,5]])
 |      >>> A.nonzero()
 |      (array([0, 0, 1, 2, 2]), array([0, 1, 2, 0, 2]))
 |  
 |  tocsc(self, copy=False)
 |      Convert this matrix to Compressed Sparse Column format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant csc_matrix.
 |  
 |  tocsr(self, copy=False)
 |      Convert this matrix to Compressed Sparse Row format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant csr_matrix.
 |  
 |  transpose(self, axes=None, copy=False)
 |      Reverses the dimensions of the sparse matrix.
 |      
 |      Parameters
 |      ----------
 |      axes : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value.
 |      copy : bool, optional
 |          Indicates whether or not attributes of `self` should be
 |          copied whenever possible. The degree to which attributes
 |          are copied varies depending on the type of sparse matrix
 |          being used.
 |      
 |      Returns
 |      -------
 |      p : `self` with the dimensions reversed.
 |      
 |      See Also
 |      --------
 |      np.matrix.transpose : NumPy's implementation of 'transpose'
 |                            for matrices
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  format = 'csc'
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.compressed._cs_matrix:
 |  
 |  __eq__(self, other)
 |      Return self==value.
 |  
 |  __ge__(self, other)
 |      Return self>=value.
 |  
 |  __gt__(self, other)
 |      Return self>value.
 |  
 |  __init__(self, arg1, shape=None, dtype=None, copy=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __le__(self, other)
 |      Return self<=value.
 |  
 |  __lt__(self, other)
 |      Return self<value.
 |  
 |  __ne__(self, other)
 |      Return self!=value.
 |  
 |  __setitem__(self, index, x)
 |  
 |  check_format(self, full_check=True)
 |      check whether the matrix format is valid
 |      
 |      Parameters
 |      ----------
 |      full_check : bool, optional
 |          If `True`, rigorous check, O(N) operations. Otherwise
 |          basic check, O(1) operations (default True).
 |  
 |  diagonal(self, k=0)
 |      Returns the k-th diagonal of the matrix.
 |      
 |      Parameters
 |      ----------
 |      k : int, optional
 |          Which diagonal to set, corresponding to elements a[i, i+k].
 |          Default: 0 (the main diagonal).
 |      
 |          .. versionadded:: 1.0
 |      
 |      See also
 |      --------
 |      numpy.diagonal : Equivalent numpy function.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> A.diagonal()
 |      array([1, 0, 5])
 |      >>> A.diagonal(k=1)
 |      array([2, 3])
 |  
 |  eliminate_zeros(self)
 |      Remove zero entries from the matrix
 |      
 |      This is an *in place* operation
 |  
 |  getnnz(self, axis=None)
 |      Number of stored values, including explicit zeros.
 |      
 |      Parameters
 |      ----------
 |      axis : None, 0, or 1
 |          Select between the number of values across the whole matrix, in
 |          each column, or in each row.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  maximum(self, other)
 |      Element-wise maximum between this and another matrix.
 |  
 |  minimum(self, other)
 |      Element-wise minimum between this and another matrix.
 |  
 |  multiply(self, other)
 |      Point-wise multiplication by another matrix, vector, or
 |      scalar.
 |  
 |  prune(self)
 |      Remove empty space after all non-zero elements.
 |  
 |  resize(self, *shape)
 |      Resize the matrix in-place to dimensions given by ``shape``
 |      
 |      Any elements that lie within the new shape will remain at the same
 |      indices, while non-zero elements lying outside the new shape are
 |      removed.
 |      
 |      Parameters
 |      ----------
 |      shape : (int, int)
 |          number of rows and columns in the new matrix
 |      
 |      Notes
 |      -----
 |      The semantics are not identical to `numpy.ndarray.resize` or
 |      `numpy.resize`.  Here, the same data will be maintained at each index
 |      before and after reshape, if that index is within the new bounds.  In
 |      numpy, resizing maintains contiguity of the array, moving elements
 |      around in the logical matrix but not within a flattened representation.
 |      
 |      We give no guarantees about whether the underlying data attributes
 |      (arrays, etc.) will be modified in place or replaced with new objects.
 |  
 |  sort_indices(self)
 |      Sort the indices of this matrix *in place*
 |  
 |  sorted_indices(self)
 |      Return a copy of this matrix with sorted indices
 |  
 |  sum(self, axis=None, dtype=None, out=None)
 |      Sum the matrix elements over a given axis.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the sum of all the matrix elements, returning a scalar
 |          (i.e. `axis` = `None`).
 |      dtype : dtype, optional
 |          The type of the returned matrix and of the accumulator in which
 |          the elements are summed.  The dtype of `a` is used by default
 |          unless `a` has an integer dtype of less precision than the default
 |          platform integer.  In that case, if `a` is signed then the platform
 |          integer is used while if `a` is unsigned then an unsigned integer
 |          of the same precision as the platform integer is used.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      sum_along_axis : np.matrix
 |          A matrix with the same shape as `self`, with the specified
 |          axis removed.
 |      
 |      See Also
 |      --------
 |      np.matrix.sum : NumPy's implementation of 'sum' for matrices
 |  
 |  sum_duplicates(self)
 |      Eliminate duplicate matrix entries by adding them together
 |      
 |      The is an *in place* operation
 |  
 |  toarray(self, order=None, out=None)
 |      Return a dense ndarray representation of this matrix.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F'}, optional
 |          Whether to store multi-dimensional data in C (row-major)
 |          or Fortran (column-major) order in memory. The default
 |          is 'None', indicating the NumPy default of C-ordered.
 |          Cannot be specified in conjunction with the `out`
 |          argument.
 |      
 |      out : ndarray, 2-dimensional, optional
 |          If specified, uses this array as the output buffer
 |          instead of allocating a new array to return. The provided
 |          array must have the same shape and dtype as the sparse
 |          matrix on which you are calling the method. For most
 |          sparse types, `out` is required to be memory contiguous
 |          (either C or Fortran ordered).
 |      
 |      Returns
 |      -------
 |      arr : ndarray, 2-dimensional
 |          An array with the same shape and containing the same
 |          data represented by the sparse matrix, with the requested
 |          memory order. If `out` was passed, the same object is
 |          returned after being modified in-place to contain the
 |          appropriate values.
 |  
 |  tocoo(self, copy=True)
 |      Convert this matrix to COOrdinate format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant coo_matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.compressed._cs_matrix:
 |  
 |  has_canonical_format
 |      Determine whether the matrix has sorted indices and no duplicates
 |      
 |      Returns
 |          - True: if the above applies
 |          - False: otherwise
 |      
 |      has_canonical_format implies has_sorted_indices, so if the latter flag
 |      is False, so will the former be; if the former is found True, the
 |      latter flag is also set.
 |  
 |  has_sorted_indices
 |      Determine whether the matrix has sorted indices
 |      
 |      Returns
 |          - True: if the indices of the matrix are in sorted order
 |          - False: otherwise
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.sparse.compressed._cs_matrix:
 |  
 |  __hash__ = None
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._data_matrix:
 |  
 |  __abs__(self)
 |  
 |  __imul__(self, other)
 |  
 |  __itruediv__(self, other)
 |  
 |  __neg__(self)
 |  
 |  arcsin(self)
 |      Element-wise arcsin.
 |      
 |      See numpy.arcsin for more information.
 |  
 |  arcsinh(self)
 |      Element-wise arcsinh.
 |      
 |      See numpy.arcsinh for more information.
 |  
 |  arctan(self)
 |      Element-wise arctan.
 |      
 |      See numpy.arctan for more information.
 |  
 |  arctanh(self)
 |      Element-wise arctanh.
 |      
 |      See numpy.arctanh for more information.
 |  
 |  astype(self, dtype, casting='unsafe', copy=True)
 |      Cast the matrix elements to a specified type.
 |      
 |      Parameters
 |      ----------
 |      dtype : string or numpy dtype
 |          Typecode or data-type to which to cast the data.
 |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
 |          Controls what kind of data casting may occur.
 |          Defaults to 'unsafe' for backwards compatibility.
 |          'no' means the data types should not be cast at all.
 |          'equiv' means only byte-order changes are allowed.
 |          'safe' means only casts which can preserve values are allowed.
 |          'same_kind' means only safe casts or casts within a kind,
 |          like float64 to float32, are allowed.
 |          'unsafe' means any data conversions may be done.
 |      copy : bool, optional
 |          If `copy` is `False`, the result might share some memory with this
 |          matrix. If `copy` is `True`, it is guaranteed that the result and
 |          this matrix do not share any memory.
 |  
 |  ceil(self)
 |      Element-wise ceil.
 |      
 |      See numpy.ceil for more information.
 |  
 |  conj(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  copy(self)
 |      Returns a copy of this matrix.
 |      
 |      No data/indices will be shared between the returned value and current
 |      matrix.
 |  
 |  count_nonzero(self)
 |      Number of non-zero entries, equivalent to
 |      
 |      np.count_nonzero(a.toarray())
 |      
 |      Unlike getnnz() and the nnz property, which return the number of stored
 |      entries (the length of the data attribute), this method counts the
 |      actual number of non-zero entries in data.
 |  
 |  deg2rad(self)
 |      Element-wise deg2rad.
 |      
 |      See numpy.deg2rad for more information.
 |  
 |  expm1(self)
 |      Element-wise expm1.
 |      
 |      See numpy.expm1 for more information.
 |  
 |  floor(self)
 |      Element-wise floor.
 |      
 |      See numpy.floor for more information.
 |  
 |  log1p(self)
 |      Element-wise log1p.
 |      
 |      See numpy.log1p for more information.
 |  
 |  power(self, n, dtype=None)
 |      This function performs element-wise power.
 |      
 |      Parameters
 |      ----------
 |      n : n is a scalar
 |      
 |      dtype : If dtype is not specified, the current dtype will be preserved.
 |  
 |  rad2deg(self)
 |      Element-wise rad2deg.
 |      
 |      See numpy.rad2deg for more information.
 |  
 |  rint(self)
 |      Element-wise rint.
 |      
 |      See numpy.rint for more information.
 |  
 |  sign(self)
 |      Element-wise sign.
 |      
 |      See numpy.sign for more information.
 |  
 |  sin(self)
 |      Element-wise sin.
 |      
 |      See numpy.sin for more information.
 |  
 |  sinh(self)
 |      Element-wise sinh.
 |      
 |      See numpy.sinh for more information.
 |  
 |  sqrt(self)
 |      Element-wise sqrt.
 |      
 |      See numpy.sqrt for more information.
 |  
 |  tan(self)
 |      Element-wise tan.
 |      
 |      See numpy.tan for more information.
 |  
 |  tanh(self)
 |      Element-wise tanh.
 |      
 |      See numpy.tanh for more information.
 |  
 |  trunc(self)
 |      Element-wise trunc.
 |      
 |      See numpy.trunc for more information.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.data._data_matrix:
 |  
 |  dtype
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.base.spmatrix:
 |  
 |  __add__(self, other)
 |  
 |  __bool__(self)
 |  
 |  __div__(self, other)
 |  
 |  __getattr__(self, attr)
 |  
 |  __iadd__(self, other)
 |  
 |  __idiv__(self, other)
 |  
 |  __isub__(self, other)
 |  
 |  __len__(self)
 |      # What should len(sparse) return? For consistency with dense matrices,
 |      # perhaps it should be the number of rows?  But for some uses the number of
 |      # non-zeros is more important.  For now, raise an exception!
 |  
 |  __matmul__(self, other)
 |  
 |  __mul__(self, other)
 |      interpret other and call one of the following
 |      
 |      self._mul_scalar()
 |      self._mul_vector()
 |      self._mul_multivector()
 |      self._mul_sparse_matrix()
 |  
 |  __nonzero__ = __bool__(self)
 |  
 |  __pow__(self, other)
 |  
 |  __radd__(self, other)
 |  
 |  __rdiv__(self, other)
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __rmatmul__(self, other)
 |  
 |  __rmul__(self, other)
 |  
 |  __rsub__(self, other)
 |  
 |  __rtruediv__(self, other)
 |  
 |  __str__(self)
 |      Return str(self).
 |  
 |  __sub__(self, other)
 |  
 |  __truediv__(self, other)
 |  
 |  asformat(self, format, copy=False)
 |      Return this matrix in the passed sparse format.
 |      
 |      Parameters
 |      ----------
 |      format : {str, None}
 |          The desired sparse matrix format (""csr"", ""csc"", ""lil"", ""dok"", ...)
 |          or None for no conversion.
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : This matrix in the passed sparse format.
 |  
 |  asfptype(self)
 |      Upcast matrix to a floating point format (if necessary)
 |  
 |  conjugate(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  dot(self, other)
 |      Ordinary dot product
 |      
 |      Examples
 |      --------
 |      >>> import numpy as np
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> v = np.array([1, 0, -1])
 |      >>> A.dot(v)
 |      array([ 1, -3, -1], dtype=int64)
 |  
 |  getH(self)
 |      Return the Hermitian transpose of this matrix.
 |      
 |      See Also
 |      --------
 |      np.matrix.getH : NumPy's implementation of `getH` for matrices
 |  
 |  get_shape(self)
 |      Get shape of a matrix.
 |  
 |  getformat(self)
 |      Format of a matrix representation as a string.
 |  
 |  getmaxprint(self)
 |      Maximum number of elements to display when printed.
 |  
 |  mean(self, axis=None, dtype=None, out=None)
 |      Compute the arithmetic mean along the specified axis.
 |      
 |      Returns the average of the matrix elements. The average is taken
 |      over all elements in the matrix by default, otherwise over the
 |      specified axis. `float64` intermediate and return values are used
 |      for integer inputs.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the mean is computed. The default is to compute
 |          the mean of all elements in the matrix (i.e. `axis` = `None`).
 |      dtype : data-type, optional
 |          Type to use in computing the mean. For integer inputs, the default
 |          is `float64`; for floating point inputs, it is the same as the
 |          input dtype.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      m : np.matrix
 |      
 |      See Also
 |      --------
 |      np.matrix.mean : NumPy's implementation of 'mean' for matrices
 |  
 |  reshape(self, *args, **kwargs)
 |      reshape(self, shape, order='C', copy=False)
 |      
 |      Gives a new shape to a sparse matrix without changing its data.
 |      
 |      Parameters
 |      ----------
 |      shape : length-2 tuple of ints
 |          The new shape should be compatible with the original shape.
 |      order : {'C', 'F'}, optional
 |          Read the elements using this index order. 'C' means to read and
 |          write the elements using C-like index order; e.g. read entire first
 |          row, then second row, etc. 'F' means to read and write the elements
 |          using Fortran-like index order; e.g. read entire first column, then
 |          second column, etc.
 |      copy : bool, optional
 |          Indicates whether or not attributes of self should be copied
 |          whenever possible. The degree to which attributes are copied varies
 |          depending on the type of sparse matrix being used.
 |      
 |      Returns
 |      -------
 |      reshaped_matrix : sparse matrix
 |          A sparse matrix with the given `shape`, not necessarily of the same
 |          format as the current object.
 |      
 |      See Also
 |      --------
 |      np.matrix.reshape : NumPy's implementation of 'reshape' for matrices
 |  
 |  set_shape(self, shape)
 |      See `reshape`.
 |  
 |  setdiag(self, values, k=0)
 |      Set diagonal or off-diagonal elements of the array.
 |      
 |      Parameters
 |      ----------
 |      values : array_like
 |          New values of the diagonal elements.
 |      
 |          Values may have any length.  If the diagonal is longer than values,
 |          then the remaining diagonal entries will not be set.  If values if
 |          longer than the diagonal, then the remaining values are ignored.
 |      
 |          If a scalar value is given, all of the diagonal is set to it.
 |      
 |      k : int, optional
 |          Which off-diagonal to set, corresponding to elements a[i,i+k].
 |          Default: 0 (the main diagonal).
 |  
 |  tobsr(self, blocksize=None, copy=False)
 |      Convert this matrix to Block Sparse Row format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant bsr_matrix.
 |      
 |      When blocksize=(R, C) is provided, it will be used for construction of
 |      the bsr_matrix.
 |  
 |  todense(self, order=None, out=None)
 |      Return a dense matrix representation of this matrix.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F'}, optional
 |          Whether to store multi-dimensional data in C (row-major)
 |          or Fortran (column-major) order in memory. The default
 |          is 'None', indicating the NumPy default of C-ordered.
 |          Cannot be specified in conjunction with the `out`
 |          argument.
 |      
 |      out : ndarray, 2-dimensional, optional
 |          If specified, uses this array (or `numpy.matrix`) as the
 |          output buffer instead of allocating a new array to
 |          return. The provided array must have the same shape and
 |          dtype as the sparse matrix on which you are calling the
 |          method.
 |      
 |      Returns
 |      -------
 |      arr : numpy.matrix, 2-dimensional
 |          A NumPy matrix object with the same shape and containing
 |          the same data represented by the sparse matrix, with the
 |          requested memory order. If `out` was passed and was an
 |          array (rather than a `numpy.matrix`), it will be filled
 |          with the appropriate values and returned wrapped in a
 |          `numpy.matrix` object that shares the same memory.
 |  
 |  todia(self, copy=False)
 |      Convert this matrix to sparse DIAgonal format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dia_matrix.
 |  
 |  todok(self, copy=False)
 |      Convert this matrix to Dictionary Of Keys format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dok_matrix.
 |  
 |  tolil(self, copy=False)
 |      Convert this matrix to LInked List format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant lil_matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.base.spmatrix:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  nnz
 |      Number of stored values, including explicit zeros.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  shape
 |      Get shape of a matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.sparse.base.spmatrix:
 |  
 |  __array_priority__ = 10.1
 |  
 |  ndim = 2
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._minmax_mixin:
 |  
 |  argmax(self, axis=None, out=None)
 |      Return indices of maximum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several maximum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmax is computed. If None (default), index
 |          of the maximum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      ind : np.matrix or int
 |          Indices of maximum elements. If matrix, its size along `axis` is 1.
 |  
 |  argmin(self, axis=None, out=None)
 |      Return indices of minimum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several minimum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmin is computed. If None (default), index
 |          of the minimum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |       ind : np.matrix or int
 |          Indices of minimum elements. If matrix, its size along `axis` is 1.
 |  
 |  max(self, axis=None, out=None)
 |      Return the maximum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the maximum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amax : coo_matrix or scalar
 |          Maximum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      min : The minimum value of a sparse matrix along a given axis.
 |      np.matrix.max : NumPy's implementation of 'max' for matrices
 |  
 |  min(self, axis=None, out=None)
 |      Return the minimum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the minimum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amin : coo_matrix or scalar
 |          Minimum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      max : The maximum value of a sparse matrix along a given axis.
 |      np.matrix.min : NumPy's implementation of 'min' for matrices
",class,"('(self, arg1, shape=None, dtype=None, copy=False)',)",scipy,1.1.0,scipy.integrate._ivp.radau.csc_matrix,integrate._ivp.radau,csc_matrix,"Python Library Documentation: class csc_matrix in module scipy.sparse.csc

class csc_matrix(scipy.sparse.compressed._cs_matrix, scipy.sparse.sputils.IndexMixin)
 |  Compressed Sparse Column matrix
 |  
 |  This can be instantiated in several ways:
 |  
 |      csc_matrix(D)
 |          with a dense matrix or rank-2 ndarray D
 |  
 |      csc_matrix(S)
 |          with another sparse matrix S (equivalent to S.tocsc())
 |  
 |      csc_matrix((M, N), [dtype])
 |          to construct an empty matrix with shape (M, N)
 |          dtype is optional, defaulting to dtype='d'.
 |  
 |      csc_matrix((data, (row_ind, col_ind)), [shape=(M, N)])
 |          where ``data``, ``row_ind`` and ``col_ind`` satisfy the
 |          relationship ``a[row_ind[k], col_ind[k]] = data[k]``.
 |  
 |      csc_matrix((data, indices, indptr), [shape=(M, N)])
 |          is the standard CSC representation where the row indices for
 |          column i are stored in ``indices[indptr[i]:indptr[i+1]]``
 |          and their corresponding values are stored in
 |          ``data[indptr[i]:indptr[i+1]]``.  If the shape parameter is
 |          not supplied, the matrix dimensions are inferred from
 |          the index arrays.
 |  
 |  Attributes
 |  ----------
 |  dtype : dtype
 |      Data type of the matrix
 |  shape : 2-tuple
 |      Shape of the matrix
 |  ndim : int
 |      Number of dimensions (this is always 2)
 |  nnz
 |      Number of nonzero elements
 |  data
 |      Data array of the matrix
 |  indices
 |      CSC format index array
 |  indptr
 |      CSC format index pointer array
 |  has_sorted_indices
 |      Whether indices are sorted
 |  
 |  Notes
 |  -----
 |  
 |  Sparse matrices can be used in arithmetic operations: they support
 |  addition, subtraction, multiplication, division, and matrix power.
 |  
 |  Advantages of the CSC format
 |      - efficient arithmetic operations CSC + CSC, CSC * CSC, etc.
 |      - efficient column slicing
 |      - fast matrix vector products (CSR, BSR may be faster)
 |  
 |  Disadvantages of the CSC format
 |    - slow row slicing operations (consider CSR)
 |    - changes to the sparsity structure are expensive (consider LIL or DOK)
 |  
 |  
 |  Examples
 |  --------
 |  
 |  >>> import numpy as np
 |  >>> from scipy.sparse import csc_matrix
 |  >>> csc_matrix((3, 4), dtype=np.int8).toarray()
 |  array([[0, 0, 0, 0],
 |         [0, 0, 0, 0],
 |         [0, 0, 0, 0]], dtype=int8)
 |  
 |  >>> row = np.array([0, 2, 2, 0, 1, 2])
 |  >>> col = np.array([0, 0, 1, 2, 2, 2])
 |  >>> data = np.array([1, 2, 3, 4, 5, 6])
 |  >>> csc_matrix((data, (row, col)), shape=(3, 3)).toarray()
 |  array([[1, 0, 4],
 |         [0, 0, 5],
 |         [2, 3, 6]])
 |  
 |  >>> indptr = np.array([0, 2, 3, 6])
 |  >>> indices = np.array([0, 2, 2, 0, 1, 2])
 |  >>> data = np.array([1, 2, 3, 4, 5, 6])
 |  >>> csc_matrix((data, indices, indptr), shape=(3, 3)).toarray()
 |  array([[1, 0, 4],
 |         [0, 0, 5],
 |         [2, 3, 6]])
 |  
 |  Method resolution order:
 |      csc_matrix
 |      scipy.sparse.compressed._cs_matrix
 |      scipy.sparse.data._data_matrix
 |      scipy.sparse.base.spmatrix
 |      scipy.sparse.data._minmax_mixin
 |      scipy.sparse.sputils.IndexMixin
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __getitem__(self, key)
 |  
 |  __iter__(self)
 |  
 |  getcol(self, i)
 |      Returns a copy of column i of the matrix, as a (m x 1)
 |      CSC matrix (column vector).
 |  
 |  getrow(self, i)
 |      Returns a copy of row i of the matrix, as a (1 x n)
 |      CSR matrix (row vector).
 |  
 |  nonzero(self)
 |      nonzero indices
 |      
 |      Returns a tuple of arrays (row,col) containing the indices
 |      of the non-zero elements of the matrix.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1,2,0],[0,0,3],[4,0,5]])
 |      >>> A.nonzero()
 |      (array([0, 0, 1, 2, 2]), array([0, 1, 2, 0, 2]))
 |  
 |  tocsc(self, copy=False)
 |      Convert this matrix to Compressed Sparse Column format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant csc_matrix.
 |  
 |  tocsr(self, copy=False)
 |      Convert this matrix to Compressed Sparse Row format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant csr_matrix.
 |  
 |  transpose(self, axes=None, copy=False)
 |      Reverses the dimensions of the sparse matrix.
 |      
 |      Parameters
 |      ----------
 |      axes : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value.
 |      copy : bool, optional
 |          Indicates whether or not attributes of `self` should be
 |          copied whenever possible. The degree to which attributes
 |          are copied varies depending on the type of sparse matrix
 |          being used.
 |      
 |      Returns
 |      -------
 |      p : `self` with the dimensions reversed.
 |      
 |      See Also
 |      --------
 |      np.matrix.transpose : NumPy's implementation of 'transpose'
 |                            for matrices
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  format = 'csc'
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.compressed._cs_matrix:
 |  
 |  __eq__(self, other)
 |      Return self==value.
 |  
 |  __ge__(self, other)
 |      Return self>=value.
 |  
 |  __gt__(self, other)
 |      Return self>value.
 |  
 |  __init__(self, arg1, shape=None, dtype=None, copy=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __le__(self, other)
 |      Return self<=value.
 |  
 |  __lt__(self, other)
 |      Return self<value.
 |  
 |  __ne__(self, other)
 |      Return self!=value.
 |  
 |  __setitem__(self, index, x)
 |  
 |  check_format(self, full_check=True)
 |      check whether the matrix format is valid
 |      
 |      Parameters
 |      ----------
 |      full_check : bool, optional
 |          If `True`, rigorous check, O(N) operations. Otherwise
 |          basic check, O(1) operations (default True).
 |  
 |  diagonal(self, k=0)
 |      Returns the k-th diagonal of the matrix.
 |      
 |      Parameters
 |      ----------
 |      k : int, optional
 |          Which diagonal to set, corresponding to elements a[i, i+k].
 |          Default: 0 (the main diagonal).
 |      
 |          .. versionadded:: 1.0
 |      
 |      See also
 |      --------
 |      numpy.diagonal : Equivalent numpy function.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> A.diagonal()
 |      array([1, 0, 5])
 |      >>> A.diagonal(k=1)
 |      array([2, 3])
 |  
 |  eliminate_zeros(self)
 |      Remove zero entries from the matrix
 |      
 |      This is an *in place* operation
 |  
 |  getnnz(self, axis=None)
 |      Number of stored values, including explicit zeros.
 |      
 |      Parameters
 |      ----------
 |      axis : None, 0, or 1
 |          Select between the number of values across the whole matrix, in
 |          each column, or in each row.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  maximum(self, other)
 |      Element-wise maximum between this and another matrix.
 |  
 |  minimum(self, other)
 |      Element-wise minimum between this and another matrix.
 |  
 |  multiply(self, other)
 |      Point-wise multiplication by another matrix, vector, or
 |      scalar.
 |  
 |  prune(self)
 |      Remove empty space after all non-zero elements.
 |  
 |  resize(self, *shape)
 |      Resize the matrix in-place to dimensions given by ``shape``
 |      
 |      Any elements that lie within the new shape will remain at the same
 |      indices, while non-zero elements lying outside the new shape are
 |      removed.
 |      
 |      Parameters
 |      ----------
 |      shape : (int, int)
 |          number of rows and columns in the new matrix
 |      
 |      Notes
 |      -----
 |      The semantics are not identical to `numpy.ndarray.resize` or
 |      `numpy.resize`.  Here, the same data will be maintained at each index
 |      before and after reshape, if that index is within the new bounds.  In
 |      numpy, resizing maintains contiguity of the array, moving elements
 |      around in the logical matrix but not within a flattened representation.
 |      
 |      We give no guarantees about whether the underlying data attributes
 |      (arrays, etc.) will be modified in place or replaced with new objects.
 |  
 |  sort_indices(self)
 |      Sort the indices of this matrix *in place*
 |  
 |  sorted_indices(self)
 |      Return a copy of this matrix with sorted indices
 |  
 |  sum(self, axis=None, dtype=None, out=None)
 |      Sum the matrix elements over a given axis.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the sum of all the matrix elements, returning a scalar
 |          (i.e. `axis` = `None`).
 |      dtype : dtype, optional
 |          The type of the returned matrix and of the accumulator in which
 |          the elements are summed.  The dtype of `a` is used by default
 |          unless `a` has an integer dtype of less precision than the default
 |          platform integer.  In that case, if `a` is signed then the platform
 |          integer is used while if `a` is unsigned then an unsigned integer
 |          of the same precision as the platform integer is used.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      sum_along_axis : np.matrix
 |          A matrix with the same shape as `self`, with the specified
 |          axis removed.
 |      
 |      See Also
 |      --------
 |      np.matrix.sum : NumPy's implementation of 'sum' for matrices
 |  
 |  sum_duplicates(self)
 |      Eliminate duplicate matrix entries by adding them together
 |      
 |      The is an *in place* operation
 |  
 |  toarray(self, order=None, out=None)
 |      Return a dense ndarray representation of this matrix.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F'}, optional
 |          Whether to store multi-dimensional data in C (row-major)
 |          or Fortran (column-major) order in memory. The default
 |          is 'None', indicating the NumPy default of C-ordered.
 |          Cannot be specified in conjunction with the `out`
 |          argument.
 |      
 |      out : ndarray, 2-dimensional, optional
 |          If specified, uses this array as the output buffer
 |          instead of allocating a new array to return. The provided
 |          array must have the same shape and dtype as the sparse
 |          matrix on which you are calling the method. For most
 |          sparse types, `out` is required to be memory contiguous
 |          (either C or Fortran ordered).
 |      
 |      Returns
 |      -------
 |      arr : ndarray, 2-dimensional
 |          An array with the same shape and containing the same
 |          data represented by the sparse matrix, with the requested
 |          memory order. If `out` was passed, the same object is
 |          returned after being modified in-place to contain the
 |          appropriate values.
 |  
 |  tocoo(self, copy=True)
 |      Convert this matrix to COOrdinate format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant coo_matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.compressed._cs_matrix:
 |  
 |  has_canonical_format
 |      Determine whether the matrix has sorted indices and no duplicates
 |      
 |      Returns
 |          - True: if the above applies
 |          - False: otherwise
 |      
 |      has_canonical_format implies has_sorted_indices, so if the latter flag
 |      is False, so will the former be; if the former is found True, the
 |      latter flag is also set.
 |  
 |  has_sorted_indices
 |      Determine whether the matrix has sorted indices
 |      
 |      Returns
 |          - True: if the indices of the matrix are in sorted order
 |          - False: otherwise
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.sparse.compressed._cs_matrix:
 |  
 |  __hash__ = None
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._data_matrix:
 |  
 |  __abs__(self)
 |  
 |  __imul__(self, other)
 |  
 |  __itruediv__(self, other)
 |  
 |  __neg__(self)
 |  
 |  arcsin(self)
 |      Element-wise arcsin.
 |      
 |      See numpy.arcsin for more information.
 |  
 |  arcsinh(self)
 |      Element-wise arcsinh.
 |      
 |      See numpy.arcsinh for more information.
 |  
 |  arctan(self)
 |      Element-wise arctan.
 |      
 |      See numpy.arctan for more information.
 |  
 |  arctanh(self)
 |      Element-wise arctanh.
 |      
 |      See numpy.arctanh for more information.
 |  
 |  astype(self, dtype, casting='unsafe', copy=True)
 |      Cast the matrix elements to a specified type.
 |      
 |      Parameters
 |      ----------
 |      dtype : string or numpy dtype
 |          Typecode or data-type to which to cast the data.
 |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
 |          Controls what kind of data casting may occur.
 |          Defaults to 'unsafe' for backwards compatibility.
 |          'no' means the data types should not be cast at all.
 |          'equiv' means only byte-order changes are allowed.
 |          'safe' means only casts which can preserve values are allowed.
 |          'same_kind' means only safe casts or casts within a kind,
 |          like float64 to float32, are allowed.
 |          'unsafe' means any data conversions may be done.
 |      copy : bool, optional
 |          If `copy` is `False`, the result might share some memory with this
 |          matrix. If `copy` is `True`, it is guaranteed that the result and
 |          this matrix do not share any memory.
 |  
 |  ceil(self)
 |      Element-wise ceil.
 |      
 |      See numpy.ceil for more information.
 |  
 |  conj(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  copy(self)
 |      Returns a copy of this matrix.
 |      
 |      No data/indices will be shared between the returned value and current
 |      matrix.
 |  
 |  count_nonzero(self)
 |      Number of non-zero entries, equivalent to
 |      
 |      np.count_nonzero(a.toarray())
 |      
 |      Unlike getnnz() and the nnz property, which return the number of stored
 |      entries (the length of the data attribute), this method counts the
 |      actual number of non-zero entries in data.
 |  
 |  deg2rad(self)
 |      Element-wise deg2rad.
 |      
 |      See numpy.deg2rad for more information.
 |  
 |  expm1(self)
 |      Element-wise expm1.
 |      
 |      See numpy.expm1 for more information.
 |  
 |  floor(self)
 |      Element-wise floor.
 |      
 |      See numpy.floor for more information.
 |  
 |  log1p(self)
 |      Element-wise log1p.
 |      
 |      See numpy.log1p for more information.
 |  
 |  power(self, n, dtype=None)
 |      This function performs element-wise power.
 |      
 |      Parameters
 |      ----------
 |      n : n is a scalar
 |      
 |      dtype : If dtype is not specified, the current dtype will be preserved.
 |  
 |  rad2deg(self)
 |      Element-wise rad2deg.
 |      
 |      See numpy.rad2deg for more information.
 |  
 |  rint(self)
 |      Element-wise rint.
 |      
 |      See numpy.rint for more information.
 |  
 |  sign(self)
 |      Element-wise sign.
 |      
 |      See numpy.sign for more information.
 |  
 |  sin(self)
 |      Element-wise sin.
 |      
 |      See numpy.sin for more information.
 |  
 |  sinh(self)
 |      Element-wise sinh.
 |      
 |      See numpy.sinh for more information.
 |  
 |  sqrt(self)
 |      Element-wise sqrt.
 |      
 |      See numpy.sqrt for more information.
 |  
 |  tan(self)
 |      Element-wise tan.
 |      
 |      See numpy.tan for more information.
 |  
 |  tanh(self)
 |      Element-wise tanh.
 |      
 |      See numpy.tanh for more information.
 |  
 |  trunc(self)
 |      Element-wise trunc.
 |      
 |      See numpy.trunc for more information.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.data._data_matrix:
 |  
 |  dtype
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.base.spmatrix:
 |  
 |  __add__(self, other)
 |  
 |  __bool__(self)
 |  
 |  __div__(self, other)
 |  
 |  __getattr__(self, attr)
 |  
 |  __iadd__(self, other)
 |  
 |  __idiv__(self, other)
 |  
 |  __isub__(self, other)
 |  
 |  __len__(self)
 |      # What should len(sparse) return? For consistency with dense matrices,
 |      # perhaps it should be the number of rows?  But for some uses the number of
 |      # non-zeros is more important.  For now, raise an exception!
 |  
 |  __matmul__(self, other)
 |  
 |  __mul__(self, other)
 |      interpret other and call one of the following
 |      
 |      self._mul_scalar()
 |      self._mul_vector()
 |      self._mul_multivector()
 |      self._mul_sparse_matrix()
 |  
 |  __nonzero__ = __bool__(self)
 |  
 |  __pow__(self, other)
 |  
 |  __radd__(self, other)
 |  
 |  __rdiv__(self, other)
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __rmatmul__(self, other)
 |  
 |  __rmul__(self, other)
 |  
 |  __rsub__(self, other)
 |  
 |  __rtruediv__(self, other)
 |  
 |  __str__(self)
 |      Return str(self).
 |  
 |  __sub__(self, other)
 |  
 |  __truediv__(self, other)
 |  
 |  asformat(self, format, copy=False)
 |      Return this matrix in the passed sparse format.
 |      
 |      Parameters
 |      ----------
 |      format : {str, None}
 |          The desired sparse matrix format (""csr"", ""csc"", ""lil"", ""dok"", ...)
 |          or None for no conversion.
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : This matrix in the passed sparse format.
 |  
 |  asfptype(self)
 |      Upcast matrix to a floating point format (if necessary)
 |  
 |  conjugate(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  dot(self, other)
 |      Ordinary dot product
 |      
 |      Examples
 |      --------
 |      >>> import numpy as np
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> v = np.array([1, 0, -1])
 |      >>> A.dot(v)
 |      array([ 1, -3, -1], dtype=int64)
 |  
 |  getH(self)
 |      Return the Hermitian transpose of this matrix.
 |      
 |      See Also
 |      --------
 |      np.matrix.getH : NumPy's implementation of `getH` for matrices
 |  
 |  get_shape(self)
 |      Get shape of a matrix.
 |  
 |  getformat(self)
 |      Format of a matrix representation as a string.
 |  
 |  getmaxprint(self)
 |      Maximum number of elements to display when printed.
 |  
 |  mean(self, axis=None, dtype=None, out=None)
 |      Compute the arithmetic mean along the specified axis.
 |      
 |      Returns the average of the matrix elements. The average is taken
 |      over all elements in the matrix by default, otherwise over the
 |      specified axis. `float64` intermediate and return values are used
 |      for integer inputs.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the mean is computed. The default is to compute
 |          the mean of all elements in the matrix (i.e. `axis` = `None`).
 |      dtype : data-type, optional
 |          Type to use in computing the mean. For integer inputs, the default
 |          is `float64`; for floating point inputs, it is the same as the
 |          input dtype.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      m : np.matrix
 |      
 |      See Also
 |      --------
 |      np.matrix.mean : NumPy's implementation of 'mean' for matrices
 |  
 |  reshape(self, *args, **kwargs)
 |      reshape(self, shape, order='C', copy=False)
 |      
 |      Gives a new shape to a sparse matrix without changing its data.
 |      
 |      Parameters
 |      ----------
 |      shape : length-2 tuple of ints
 |          The new shape should be compatible with the original shape.
 |      order : {'C', 'F'}, optional
 |          Read the elements using this index order. 'C' means to read and
 |          write the elements using C-like index order; e.g. read entire first
 |          row, then second row, etc. 'F' means to read and write the elements
 |          using Fortran-like index order; e.g. read entire first column, then
 |          second column, etc.
 |      copy : bool, optional
 |          Indicates whether or not attributes of self should be copied
 |          whenever possible. The degree to which attributes are copied varies
 |          depending on the type of sparse matrix being used.
 |      
 |      Returns
 |      -------
 |      reshaped_matrix : sparse matrix
 |          A sparse matrix with the given `shape`, not necessarily of the same
 |          format as the current object.
 |      
 |      See Also
 |      --------
 |      np.matrix.reshape : NumPy's implementation of 'reshape' for matrices
 |  
 |  set_shape(self, shape)
 |      See `reshape`.
 |  
 |  setdiag(self, values, k=0)
 |      Set diagonal or off-diagonal elements of the array.
 |      
 |      Parameters
 |      ----------
 |      values : array_like
 |          New values of the diagonal elements.
 |      
 |          Values may have any length.  If the diagonal is longer than values,
 |          then the remaining diagonal entries will not be set.  If values if
 |          longer than the diagonal, then the remaining values are ignored.
 |      
 |          If a scalar value is given, all of the diagonal is set to it.
 |      
 |      k : int, optional
 |          Which off-diagonal to set, corresponding to elements a[i,i+k].
 |          Default: 0 (the main diagonal).
 |  
 |  tobsr(self, blocksize=None, copy=False)
 |      Convert this matrix to Block Sparse Row format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant bsr_matrix.
 |      
 |      When blocksize=(R, C) is provided, it will be used for construction of
 |      the bsr_matrix.
 |  
 |  todense(self, order=None, out=None)
 |      Return a dense matrix representation of this matrix.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F'}, optional
 |          Whether to store multi-dimensional data in C (row-major)
 |          or Fortran (column-major) order in memory. The default
 |          is 'None', indicating the NumPy default of C-ordered.
 |          Cannot be specified in conjunction with the `out`
 |          argument.
 |      
 |      out : ndarray, 2-dimensional, optional
 |          If specified, uses this array (or `numpy.matrix`) as the
 |          output buffer instead of allocating a new array to
 |          return. The provided array must have the same shape and
 |          dtype as the sparse matrix on which you are calling the
 |          method.
 |      
 |      Returns
 |      -------
 |      arr : numpy.matrix, 2-dimensional
 |          A NumPy matrix object with the same shape and containing
 |          the same data represented by the sparse matrix, with the
 |          requested memory order. If `out` was passed and was an
 |          array (rather than a `numpy.matrix`), it will be filled
 |          with the appropriate values and returned wrapped in a
 |          `numpy.matrix` object that shares the same memory.
 |  
 |  todia(self, copy=False)
 |      Convert this matrix to sparse DIAgonal format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dia_matrix.
 |  
 |  todok(self, copy=False)
 |      Convert this matrix to Dictionary Of Keys format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dok_matrix.
 |  
 |  tolil(self, copy=False)
 |      Convert this matrix to LInked List format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant lil_matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.base.spmatrix:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  nnz
 |      Number of stored values, including explicit zeros.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  shape
 |      Get shape of a matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.sparse.base.spmatrix:
 |  
 |  __array_priority__ = 10.1
 |  
 |  ndim = 2
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._minmax_mixin:
 |  
 |  argmax(self, axis=None, out=None)
 |      Return indices of maximum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several maximum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmax is computed. If None (default), index
 |          of the maximum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      ind : np.matrix or int
 |          Indices of maximum elements. If matrix, its size along `axis` is 1.
 |  
 |  argmin(self, axis=None, out=None)
 |      Return indices of minimum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several minimum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmin is computed. If None (default), index
 |          of the minimum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |       ind : np.matrix or int
 |          Indices of minimum elements. If matrix, its size along `axis` is 1.
 |  
 |  max(self, axis=None, out=None)
 |      Return the maximum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the maximum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amax : coo_matrix or scalar
 |          Maximum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      min : The minimum value of a sparse matrix along a given axis.
 |      np.matrix.max : NumPy's implementation of 'max' for matrices
 |  
 |  min(self, axis=None, out=None)
 |      Return the minimum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the minimum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amin : coo_matrix or scalar
 |          Minimum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      max : The maximum value of a sparse matrix along a given axis.
 |      np.matrix.min : NumPy's implementation of 'min' for matrices
",class,"('self', 'arg1', 'shape', 'dtype', 'copy')","(nan, nan, None, None, False)","(nan, nan, 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, arg1, shape=None, dtype=None, copy=False)',)"
scipy,1.1.0,scipy.integrate._ivp.radau.eye,integrate._ivp.radau,eye,"Python Library Documentation: function eye in module scipy.sparse.construct

eye(m, n=None, k=0, dtype=<class 'float'>, format=None)
    Sparse matrix with ones on diagonal
    
    Returns a sparse (m x n) matrix where the k-th diagonal
    is all ones and everything else is zeros.
    
    Parameters
    ----------
    m : int
        Number of rows in the matrix.
    n : int, optional
        Number of columns. Default: `m`.
    k : int, optional
        Diagonal to place ones on. Default: 0 (main diagonal).
    dtype : dtype, optional
        Data type of the matrix.
    format : str, optional
        Sparse format of the result, e.g. format=""csr"", etc.
    
    Examples
    --------
    >>> from scipy import sparse
    >>> sparse.eye(3).toarray()
    array([[ 1.,  0.,  0.],
           [ 0.,  1.,  0.],
           [ 0.,  0.,  1.]])
    >>> sparse.eye(3, dtype=np.int8)
    <3x3 sparse matrix of type '<class 'numpy.int8'>'
        with 3 stored elements (1 diagonals) in DIAgonal format>
",function,"(""(m, n=None, k=0, dtype=<class 'float'>, format=None)"",)",scipy,1.1.0,scipy.integrate._ivp.radau.eye,integrate._ivp.radau,eye,"Python Library Documentation: function eye in module scipy.sparse.construct

eye(m, n=None, k=0, dtype=<class 'float'>, format=None)
    Sparse matrix with ones on diagonal
    
    Returns a sparse (m x n) matrix where the k-th diagonal
    is all ones and everything else is zeros.
    
    Parameters
    ----------
    m : int
        Number of rows in the matrix.
    n : int, optional
        Number of columns. Default: `m`.
    k : int, optional
        Diagonal to place ones on. Default: 0 (main diagonal).
    dtype : dtype, optional
        Data type of the matrix.
    format : str, optional
        Sparse format of the result, e.g. format=""csr"", etc.
    
    Examples
    --------
    >>> from scipy import sparse
    >>> sparse.eye(3).toarray()
    array([[ 1.,  0.,  0.],
           [ 0.,  1.,  0.],
           [ 0.,  0.,  1.]])
    >>> sparse.eye(3, dtype=np.int8)
    <3x3 sparse matrix of type '<class 'numpy.int8'>'
        with 3 stored elements (1 diagonals) in DIAgonal format>
",function,"('m', 'n', 'k', 'dtype', 'format')","(nan, None, 0, <class 'float'>, None)","(nan, 'NoneType', 'int', 'type', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(m, n=None, k=0, dtype=<class 'float'>, format=None)"",)"
scipy,1.1.0,scipy.integrate._ivp.radau.group_columns,integrate._ivp.radau,group_columns,"Python Library Documentation: function group_columns in module scipy.optimize._numdiff

group_columns(A, order=0)
    Group columns of a 2-d matrix for sparse finite differencing [1]_.
    
    Two columns are in the same group if in each row at least one of them
    has zero. A greedy sequential algorithm is used to construct groups.
    
    Parameters
    ----------
    A : array_like or sparse matrix, shape (m, n)
        Matrix of which to group columns.
    order : int, iterable of int with shape (n,) or None
        Permutation array which defines the order of columns enumeration.
        If int or None, a random permutation is used with `order` used as
        a random seed. Default is 0, that is use a random permutation but
        guarantee repeatability.
    
    Returns
    -------
    groups : ndarray of int, shape (n,)
        Contains values from 0 to n_groups-1, where n_groups is the number
        of found groups. Each value ``groups[i]`` is an index of a group to
        which i-th column assigned. The procedure was helpful only if
        n_groups is significantly less than n.
    
    References
    ----------
    .. [1] A. Curtis, M. J. D. Powell, and J. Reid, ""On the estimation of
           sparse Jacobian matrices"", Journal of the Institute of Mathematics
           and its Applications, 13 (1974), pp. 117-120.
",function,"('(A, order=0)',)",scipy,1.1.0,scipy.integrate._ivp.radau.group_columns,integrate._ivp.radau,group_columns,"Python Library Documentation: function group_columns in module scipy.optimize._numdiff

group_columns(A, order=0)
    Group columns of a 2-d matrix for sparse finite differencing [1]_.
    
    Two columns are in the same group if in each row at least one of them
    has zero. A greedy sequential algorithm is used to construct groups.
    
    Parameters
    ----------
    A : array_like or sparse matrix, shape (m, n)
        Matrix of which to group columns.
    order : int, iterable of int with shape (n,) or None
        Permutation array which defines the order of columns enumeration.
        If int or None, a random permutation is used with `order` used as
        a random seed. Default is 0, that is use a random permutation but
        guarantee repeatability.
    
    Returns
    -------
    groups : ndarray of int, shape (n,)
        Contains values from 0 to n_groups-1, where n_groups is the number
        of found groups. Each value ``groups[i]`` is an index of a group to
        which i-th column assigned. The procedure was helpful only if
        n_groups is significantly less than n.
    
    References
    ----------
    .. [1] A. Curtis, M. J. D. Powell, and J. Reid, ""On the estimation of
           sparse Jacobian matrices"", Journal of the Institute of Mathematics
           and its Applications, 13 (1974), pp. 117-120.
",function,"('A', 'order')","(nan, 0)","(nan, 'int')","('arg_info', 'arg_info')","('(A, order=0)',)"
scipy,1.1.0,scipy.integrate._ivp.radau.issparse,integrate._ivp.radau,isspmatrix,"Python Library Documentation: function isspmatrix in module scipy.sparse.base

isspmatrix(x)
    Is x of a sparse matrix type?
    
    Parameters
    ----------
    x
        object to check for being a sparse matrix
    
    Returns
    -------
    bool
        True if x is a sparse matrix, False otherwise
    
    Notes
    -----
    issparse and isspmatrix are aliases for the same function.
    
    Examples
    --------
    >>> from scipy.sparse import csr_matrix, isspmatrix
    >>> isspmatrix(csr_matrix([[5]]))
    True
    
    >>> from scipy.sparse import isspmatrix
    >>> isspmatrix(5)
    False
",function,"('(x)',)",scipy,1.1.0,scipy.integrate._ivp.radau.issparse,integrate._ivp.radau,isspmatrix,"Python Library Documentation: function isspmatrix in module scipy.sparse.base

isspmatrix(x)
    Is x of a sparse matrix type?
    
    Parameters
    ----------
    x
        object to check for being a sparse matrix
    
    Returns
    -------
    bool
        True if x is a sparse matrix, False otherwise
    
    Notes
    -----
    issparse and isspmatrix are aliases for the same function.
    
    Examples
    --------
    >>> from scipy.sparse import csr_matrix, isspmatrix
    >>> isspmatrix(csr_matrix([[5]]))
    True
    
    >>> from scipy.sparse import isspmatrix
    >>> isspmatrix(5)
    False
",function,"('x',)","(nan,)","(nan,)","('arg_info',)","('(x)',)"
scipy,1.1.0,scipy.integrate._ivp.radau.lu_factor,integrate._ivp.radau,lu_factor,"Python Library Documentation: function lu_factor in module scipy.linalg.decomp_lu

lu_factor(a, overwrite_a=False, check_finite=True)
    Compute pivoted LU decomposition of a matrix.
    
    The decomposition is::
    
        A = P L U
    
    where P is a permutation matrix, L lower triangular with unit
    diagonal elements, and U upper triangular.
    
    Parameters
    ----------
    a : (M, M) array_like
        Matrix to decompose
    overwrite_a : bool, optional
        Whether to overwrite data in A (may increase performance)
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    lu : (N, N) ndarray
        Matrix containing U in its upper triangle, and L in its lower triangle.
        The unit diagonal elements of L are not stored.
    piv : (N,) ndarray
        Pivot indices representing the permutation matrix P:
        row i of matrix was interchanged with row piv[i].
    
    See also
    --------
    lu_solve : solve an equation system using the LU factorization of a matrix
    
    Notes
    -----
    This is a wrapper to the ``*GETRF`` routines from LAPACK.
    
    Examples
    --------
    >>> from scipy.linalg import lu_factor
    >>> from numpy import tril, triu, allclose, zeros, eye
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> lu, piv = lu_factor(A)
    >>> piv
    array([2, 2, 3, 3], dtype=int32)
    
    Convert LAPACK's ``piv`` array to NumPy index and test the permutation 
    
    >>> piv_py = [2, 0, 3, 1]
    >>> L, U = np.tril(lu, k=-1) + np.eye(4), np.triu(lu)
    >>> np.allclose(A[piv_py] - L @ U, np.zeros((4, 4)))
    True
",function,"('(a, overwrite_a=False, check_finite=True)',)",scipy,1.1.0,scipy.integrate._ivp.radau.lu_factor,integrate._ivp.radau,lu_factor,"Python Library Documentation: function lu_factor in module scipy.linalg.decomp_lu

lu_factor(a, overwrite_a=False, check_finite=True)
    Compute pivoted LU decomposition of a matrix.
    
    The decomposition is::
    
        A = P L U
    
    where P is a permutation matrix, L lower triangular with unit
    diagonal elements, and U upper triangular.
    
    Parameters
    ----------
    a : (M, M) array_like
        Matrix to decompose
    overwrite_a : bool, optional
        Whether to overwrite data in A (may increase performance)
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    lu : (N, N) ndarray
        Matrix containing U in its upper triangle, and L in its lower triangle.
        The unit diagonal elements of L are not stored.
    piv : (N,) ndarray
        Pivot indices representing the permutation matrix P:
        row i of matrix was interchanged with row piv[i].
    
    See also
    --------
    lu_solve : solve an equation system using the LU factorization of a matrix
    
    Notes
    -----
    This is a wrapper to the ``*GETRF`` routines from LAPACK.
    
    Examples
    --------
    >>> from scipy.linalg import lu_factor
    >>> from numpy import tril, triu, allclose, zeros, eye
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> lu, piv = lu_factor(A)
    >>> piv
    array([2, 2, 3, 3], dtype=int32)
    
    Convert LAPACK's ``piv`` array to NumPy index and test the permutation 
    
    >>> piv_py = [2, 0, 3, 1]
    >>> L, U = np.tril(lu, k=-1) + np.eye(4), np.triu(lu)
    >>> np.allclose(A[piv_py] - L @ U, np.zeros((4, 4)))
    True
",function,"('a', 'overwrite_a', 'check_finite')","(nan, False, True)","(nan, 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info')","('(a, overwrite_a=False, check_finite=True)',)"
scipy,1.1.0,scipy.integrate._ivp.radau.lu_solve,integrate._ivp.radau,lu_solve,"Python Library Documentation: function lu_solve in module scipy.linalg.decomp_lu

lu_solve(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True)
    Solve an equation system, a x = b, given the LU factorization of a
    
    Parameters
    ----------
    (lu, piv)
        Factorization of the coefficient matrix a, as given by lu_factor
    b : array
        Right-hand side
    trans : {0, 1, 2}, optional
        Type of system to solve:
    
        =====  =========
        trans  system
        =====  =========
        0      a x   = b
        1      a^T x = b
        2      a^H x = b
        =====  =========
    overwrite_b : bool, optional
        Whether to overwrite data in b (may increase performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : array
        Solution to the system
    
    See also
    --------
    lu_factor : LU factorize a matrix
    
    Examples
    --------
    >>> from scipy.linalg import lu_factor, lu_solve
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> b = np.array([1, 1, 1, 1])
    >>> lu, piv = lu_factor(A)
    >>> x = lu_solve((lu, piv), b)
    >>> np.allclose(A @ x - b, np.zeros((4,)))
    True
",function,"('(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True)',)",scipy,1.1.0,scipy.integrate._ivp.radau.lu_solve,integrate._ivp.radau,lu_solve,"Python Library Documentation: function lu_solve in module scipy.linalg.decomp_lu

lu_solve(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True)
    Solve an equation system, a x = b, given the LU factorization of a
    
    Parameters
    ----------
    (lu, piv)
        Factorization of the coefficient matrix a, as given by lu_factor
    b : array
        Right-hand side
    trans : {0, 1, 2}, optional
        Type of system to solve:
    
        =====  =========
        trans  system
        =====  =========
        0      a x   = b
        1      a^T x = b
        2      a^H x = b
        =====  =========
    overwrite_b : bool, optional
        Whether to overwrite data in b (may increase performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : array
        Solution to the system
    
    See also
    --------
    lu_factor : LU factorize a matrix
    
    Examples
    --------
    >>> from scipy.linalg import lu_factor, lu_solve
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> b = np.array([1, 1, 1, 1])
    >>> lu, piv = lu_factor(A)
    >>> x = lu_solve((lu, piv), b)
    >>> np.allclose(A @ x - b, np.zeros((4,)))
    True
",function,"('lu_and_piv', 'b', 'trans', 'overwrite_b', 'check_finite')","(nan, nan, 0, False, True)","(nan, nan, 'int', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True)',)"
scipy,1.1.0,scipy.integrate._ivp.radau.norm,integrate._ivp.radau,norm,"Python Library Documentation: function norm in module scipy.integrate._ivp.common

norm(x)
    Compute RMS norm.
",function,"('(x)',)",scipy,1.1.0,scipy.integrate._ivp.radau.norm,integrate._ivp.radau,norm,"Python Library Documentation: function norm in module scipy.integrate._ivp.common

norm(x)
    Compute RMS norm.
",function,"('x',)","(nan,)","(nan,)","('arg_info',)","('(x)',)"
scipy,1.1.0,scipy.integrate._ivp.radau.num_jac,integrate._ivp.radau,num_jac,"Python Library Documentation: function num_jac in module scipy.integrate._ivp.common

num_jac(fun, t, y, f, threshold, factor, sparsity=None)
    Finite differences Jacobian approximation tailored for ODE solvers.
    
    This function computes finite difference approximation to the Jacobian
    matrix of `fun` with respect to `y` using forward differences.
    The Jacobian matrix has shape (n, n) and its element (i, j) is equal to
    ``d f_i / d y_j``.
    
    A special feature of this function is the ability to correct the step
    size from iteration to iteration. The main idea is to keep the finite
    difference significantly separated from its round-off error which
    approximately equals ``EPS * np.abs(f)``. It reduces a possibility of a
    huge error and assures that the estimated derivative are reasonably close
    to the true values (i.e. the finite difference approximation is at least
    qualitatively reflects the structure of the true Jacobian).
    
    Parameters
    ----------
    fun : callable
        Right-hand side of the system implemented in a vectorized fashion.
    t : float
        Current time.
    y : ndarray, shape (n,)
        Current state.
    f : ndarray, shape (n,)
        Value of the right hand side at (t, y).
    threshold : float
        Threshold for `y` value used for computing the step size as
        ``factor * np.maximum(np.abs(y), threshold)``. Typically the value of
        absolute tolerance (atol) for a solver should be passed as `threshold`.
    factor : ndarray with shape (n,) or None
        Factor to use for computing the step size. Pass None for the very
        evaluation, then use the value returned from this function.
    sparsity : tuple (structure, groups) or None
        Sparsity structure of the Jacobian, `structure` must be csc_matrix.
    
    Returns
    -------
    J : ndarray or csc_matrix, shape (n, n)
        Jacobian matrix.
    factor : ndarray, shape (n,)
        Suggested `factor` for the next evaluation.
",function,"('(fun, t, y, f, threshold, factor, sparsity=None)',)",scipy,1.1.0,scipy.integrate._ivp.radau.num_jac,integrate._ivp.radau,num_jac,"Python Library Documentation: function num_jac in module scipy.integrate._ivp.common

num_jac(fun, t, y, f, threshold, factor, sparsity=None)
    Finite differences Jacobian approximation tailored for ODE solvers.
    
    This function computes finite difference approximation to the Jacobian
    matrix of `fun` with respect to `y` using forward differences.
    The Jacobian matrix has shape (n, n) and its element (i, j) is equal to
    ``d f_i / d y_j``.
    
    A special feature of this function is the ability to correct the step
    size from iteration to iteration. The main idea is to keep the finite
    difference significantly separated from its round-off error which
    approximately equals ``EPS * np.abs(f)``. It reduces a possibility of a
    huge error and assures that the estimated derivative are reasonably close
    to the true values (i.e. the finite difference approximation is at least
    qualitatively reflects the structure of the true Jacobian).
    
    Parameters
    ----------
    fun : callable
        Right-hand side of the system implemented in a vectorized fashion.
    t : float
        Current time.
    y : ndarray, shape (n,)
        Current state.
    f : ndarray, shape (n,)
        Value of the right hand side at (t, y).
    threshold : float
        Threshold for `y` value used for computing the step size as
        ``factor * np.maximum(np.abs(y), threshold)``. Typically the value of
        absolute tolerance (atol) for a solver should be passed as `threshold`.
    factor : ndarray with shape (n,) or None
        Factor to use for computing the step size. Pass None for the very
        evaluation, then use the value returned from this function.
    sparsity : tuple (structure, groups) or None
        Sparsity structure of the Jacobian, `structure` must be csc_matrix.
    
    Returns
    -------
    J : ndarray or csc_matrix, shape (n, n)
        Jacobian matrix.
    factor : ndarray, shape (n,)
        Suggested `factor` for the next evaluation.
",function,"('fun', 't', 'y', 'f', 'threshold', 'factor', 'sparsity')","(nan, nan, nan, nan, nan, nan, None)","(nan, nan, nan, nan, nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(fun, t, y, f, threshold, factor, sparsity=None)',)"
scipy,1.1.0,scipy.integrate._ivp.radau.predict_factor,integrate._ivp.radau,predict_factor,"Python Library Documentation: function predict_factor in module scipy.integrate._ivp.radau

predict_factor(h_abs, h_abs_old, error_norm, error_norm_old)
    Predict by which factor to increase/decrease the step size.
    
    The algorithm is described in [1]_.
    
    Parameters
    ----------
    h_abs, h_abs_old : float
        Current and previous values of the step size, `h_abs_old` can be None
        (see Notes).
    error_norm, error_norm_old : float
        Current and previous values of the error norm, `error_norm_old` can
        be None (see Notes).
    
    Returns
    -------
    factor : float
        Predicted factor.
    
    Notes
    -----
    If `h_abs_old` and `error_norm_old` are both not None then a two-step
    algorithm is used, otherwise a one-step algorithm is used.
    
    References
    ----------
    .. [1] E. Hairer, S. P. Norsett G. Wanner, ""Solving Ordinary Differential
           Equations II: Stiff and Differential-Algebraic Problems"", Sec. IV.8.
",function,"('(h_abs, h_abs_old, error_norm, error_norm_old)',)",scipy,1.1.0,scipy.integrate._ivp.radau.predict_factor,integrate._ivp.radau,predict_factor,"Python Library Documentation: function predict_factor in module scipy.integrate._ivp.radau

predict_factor(h_abs, h_abs_old, error_norm, error_norm_old)
    Predict by which factor to increase/decrease the step size.
    
    The algorithm is described in [1]_.
    
    Parameters
    ----------
    h_abs, h_abs_old : float
        Current and previous values of the step size, `h_abs_old` can be None
        (see Notes).
    error_norm, error_norm_old : float
        Current and previous values of the error norm, `error_norm_old` can
        be None (see Notes).
    
    Returns
    -------
    factor : float
        Predicted factor.
    
    Notes
    -----
    If `h_abs_old` and `error_norm_old` are both not None then a two-step
    algorithm is used, otherwise a one-step algorithm is used.
    
    References
    ----------
    .. [1] E. Hairer, S. P. Norsett G. Wanner, ""Solving Ordinary Differential
           Equations II: Stiff and Differential-Algebraic Problems"", Sec. IV.8.
",function,"('h_abs', 'h_abs_old', 'error_norm', 'error_norm_old')","(nan, nan, nan, nan)","(nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(h_abs, h_abs_old, error_norm, error_norm_old)',)"
scipy,1.1.0,scipy.integrate._ivp.radau.select_initial_step,integrate._ivp.radau,select_initial_step,"Python Library Documentation: function select_initial_step in module scipy.integrate._ivp.common

select_initial_step(fun, t0, y0, f0, direction, order, rtol, atol)
    Empirically select a good initial step.
    
    The algorithm is described in [1]_.
    
    Parameters
    ----------
    fun : callable
        Right-hand side of the system.
    t0 : float
        Initial value of the independent variable.
    y0 : ndarray, shape (n,)
        Initial value of the dependent variable.
    f0 : ndarray, shape (n,)
        Initial value of the derivative, i. e. ``fun(t0, y0)``.
    direction : float
        Integration direction.
    order : float
        Method order.
    rtol : float
        Desired relative tolerance.
    atol : float
        Desired absolute tolerance.
    
    Returns
    -------
    h_abs : float
        Absolute value of the suggested initial step.
    
    References
    ----------
    .. [1] E. Hairer, S. P. Norsett G. Wanner, ""Solving Ordinary Differential
           Equations I: Nonstiff Problems"", Sec. II.4.
",function,"('(fun, t0, y0, f0, direction, order, rtol, atol)',)",scipy,1.1.0,scipy.integrate._ivp.radau.select_initial_step,integrate._ivp.radau,select_initial_step,"Python Library Documentation: function select_initial_step in module scipy.integrate._ivp.common

select_initial_step(fun, t0, y0, f0, direction, order, rtol, atol)
    Empirically select a good initial step.
    
    The algorithm is described in [1]_.
    
    Parameters
    ----------
    fun : callable
        Right-hand side of the system.
    t0 : float
        Initial value of the independent variable.
    y0 : ndarray, shape (n,)
        Initial value of the dependent variable.
    f0 : ndarray, shape (n,)
        Initial value of the derivative, i. e. ``fun(t0, y0)``.
    direction : float
        Integration direction.
    order : float
        Method order.
    rtol : float
        Desired relative tolerance.
    atol : float
        Desired absolute tolerance.
    
    Returns
    -------
    h_abs : float
        Absolute value of the suggested initial step.
    
    References
    ----------
    .. [1] E. Hairer, S. P. Norsett G. Wanner, ""Solving Ordinary Differential
           Equations I: Nonstiff Problems"", Sec. II.4.
",function,"('fun', 't0', 'y0', 'f0', 'direction', 'order', 'rtol', 'atol')","(nan, nan, nan, nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(fun, t0, y0, f0, direction, order, rtol, atol)',)"
scipy,1.1.0,scipy.integrate._ivp.radau.solve_collocation_system,integrate._ivp.radau,solve_collocation_system,"Python Library Documentation: function solve_collocation_system in module scipy.integrate._ivp.radau

solve_collocation_system(fun, t, y, h, Z0, scale, tol, LU_real, LU_complex, solve_lu)
    Solve the collocation system.
    
    Parameters
    ----------
    fun : callable
        Right-hand side of the system.
    t : float
        Current time.
    y : ndarray, shape (n,)
        Current state.
    h : float
        Step to try.
    Z0 : ndarray, shape (3, n)
        Initial guess for the solution. It determines new values of `y` at
        ``t + h * C`` as ``y + Z0``, where ``C`` is the Radau method constants.
    scale : float
        Problem tolerance scale, i.e. ``rtol * abs(y) + atol``.
    tol : float
        Tolerance to which solve the system. This value is compared with
        the normalized by `scale` error.
    LU_real, LU_complex
        LU decompositions of the system Jacobians.
    solve_lu : callable
        Callable which solves a linear system given a LU decomposition. The
        signature is ``solve_lu(LU, b)``.
    
    Returns
    -------
    converged : bool
        Whether iterations converged.
    n_iter : int
        Number of completed iterations.
    Z : ndarray, shape (3, n)
        Found solution.
    rate : float
        The rate of convergence.
",function,"('(fun, t, y, h, Z0, scale, tol, LU_real, LU_complex, solve_lu)',)",scipy,1.1.0,scipy.integrate._ivp.radau.solve_collocation_system,integrate._ivp.radau,solve_collocation_system,"Python Library Documentation: function solve_collocation_system in module scipy.integrate._ivp.radau

solve_collocation_system(fun, t, y, h, Z0, scale, tol, LU_real, LU_complex, solve_lu)
    Solve the collocation system.
    
    Parameters
    ----------
    fun : callable
        Right-hand side of the system.
    t : float
        Current time.
    y : ndarray, shape (n,)
        Current state.
    h : float
        Step to try.
    Z0 : ndarray, shape (3, n)
        Initial guess for the solution. It determines new values of `y` at
        ``t + h * C`` as ``y + Z0``, where ``C`` is the Radau method constants.
    scale : float
        Problem tolerance scale, i.e. ``rtol * abs(y) + atol``.
    tol : float
        Tolerance to which solve the system. This value is compared with
        the normalized by `scale` error.
    LU_real, LU_complex
        LU decompositions of the system Jacobians.
    solve_lu : callable
        Callable which solves a linear system given a LU decomposition. The
        signature is ``solve_lu(LU, b)``.
    
    Returns
    -------
    converged : bool
        Whether iterations converged.
    n_iter : int
        Number of completed iterations.
    Z : ndarray, shape (3, n)
        Found solution.
    rate : float
        The rate of convergence.
",function,"('fun', 't', 'y', 'h', 'Z0', 'scale', 'tol', 'LU_real', 'LU_complex', 'solve_lu')","(nan, nan, nan, nan, nan, nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan, nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(fun, t, y, h, Z0, scale, tol, LU_real, LU_complex, solve_lu)',)"
scipy,1.1.0,scipy.integrate._ivp.radau.splu,integrate._ivp.radau,splu,"Python Library Documentation: function splu in module scipy.sparse.linalg.dsolve.linsolve

splu(A, permc_spec=None, diag_pivot_thresh=None, relax=None, panel_size=None, options={})
    Compute the LU decomposition of a sparse, square matrix.
    
    Parameters
    ----------
    A : sparse matrix
        Sparse matrix to factorize. Should be in CSR or CSC format.
    permc_spec : str, optional
        How to permute the columns of the matrix for sparsity preservation.
        (default: 'COLAMD')
    
        - ``NATURAL``: natural ordering.
        - ``MMD_ATA``: minimum degree ordering on the structure of A^T A.
        - ``MMD_AT_PLUS_A``: minimum degree ordering on the structure of A^T+A.
        - ``COLAMD``: approximate minimum degree column ordering
    
    diag_pivot_thresh : float, optional
        Threshold used for a diagonal entry to be an acceptable pivot.
        See SuperLU user's guide for details [1]_
    relax : int, optional
        Expert option for customizing the degree of relaxing supernodes.
        See SuperLU user's guide for details [1]_
    panel_size : int, optional
        Expert option for customizing the panel size.
        See SuperLU user's guide for details [1]_
    options : dict, optional
        Dictionary containing additional expert options to SuperLU.
        See SuperLU user guide [1]_ (section 2.4 on the 'Options' argument)
        for more details. For example, you can specify
        ``options=dict(Equil=False, IterRefine='SINGLE'))``
        to turn equilibration off and perform a single iterative refinement.
    
    Returns
    -------
    invA : scipy.sparse.linalg.SuperLU
        Object, which has a ``solve`` method.
    
    See also
    --------
    spilu : incomplete LU decomposition
    
    Notes
    -----
    This function uses the SuperLU library.
    
    References
    ----------
    .. [1] SuperLU http://crd.lbl.gov/~xiaoye/SuperLU/
    
    Examples
    --------
    >>> from scipy.sparse import csc_matrix
    >>> from scipy.sparse.linalg import splu
    >>> A = csc_matrix([[1., 0., 0.], [5., 0., 2.], [0., -1., 0.]], dtype=float)
    >>> B = splu(A)
    >>> x = np.array([1., 2., 3.], dtype=float)
    >>> B.solve(x)
    array([ 1. , -3. , -1.5])
    >>> A.dot(B.solve(x))
    array([ 1.,  2.,  3.])
    >>> B.solve(A.dot(x))
    array([ 1.,  2.,  3.])
",function,"('(A, permc_spec=None, diag_pivot_thresh=None, relax=None, panel_size=None, options={})',)",scipy,1.1.0,scipy.integrate._ivp.radau.splu,integrate._ivp.radau,splu,"Python Library Documentation: function splu in module scipy.sparse.linalg.dsolve.linsolve

splu(A, permc_spec=None, diag_pivot_thresh=None, relax=None, panel_size=None, options={})
    Compute the LU decomposition of a sparse, square matrix.
    
    Parameters
    ----------
    A : sparse matrix
        Sparse matrix to factorize. Should be in CSR or CSC format.
    permc_spec : str, optional
        How to permute the columns of the matrix for sparsity preservation.
        (default: 'COLAMD')
    
        - ``NATURAL``: natural ordering.
        - ``MMD_ATA``: minimum degree ordering on the structure of A^T A.
        - ``MMD_AT_PLUS_A``: minimum degree ordering on the structure of A^T+A.
        - ``COLAMD``: approximate minimum degree column ordering
    
    diag_pivot_thresh : float, optional
        Threshold used for a diagonal entry to be an acceptable pivot.
        See SuperLU user's guide for details [1]_
    relax : int, optional
        Expert option for customizing the degree of relaxing supernodes.
        See SuperLU user's guide for details [1]_
    panel_size : int, optional
        Expert option for customizing the panel size.
        See SuperLU user's guide for details [1]_
    options : dict, optional
        Dictionary containing additional expert options to SuperLU.
        See SuperLU user guide [1]_ (section 2.4 on the 'Options' argument)
        for more details. For example, you can specify
        ``options=dict(Equil=False, IterRefine='SINGLE'))``
        to turn equilibration off and perform a single iterative refinement.
    
    Returns
    -------
    invA : scipy.sparse.linalg.SuperLU
        Object, which has a ``solve`` method.
    
    See also
    --------
    spilu : incomplete LU decomposition
    
    Notes
    -----
    This function uses the SuperLU library.
    
    References
    ----------
    .. [1] SuperLU http://crd.lbl.gov/~xiaoye/SuperLU/
    
    Examples
    --------
    >>> from scipy.sparse import csc_matrix
    >>> from scipy.sparse.linalg import splu
    >>> A = csc_matrix([[1., 0., 0.], [5., 0., 2.], [0., -1., 0.]], dtype=float)
    >>> B = splu(A)
    >>> x = np.array([1., 2., 3.], dtype=float)
    >>> B.solve(x)
    array([ 1. , -3. , -1.5])
    >>> A.dot(B.solve(x))
    array([ 1.,  2.,  3.])
    >>> B.solve(A.dot(x))
    array([ 1.,  2.,  3.])
",function,"('A', 'permc_spec', 'diag_pivot_thresh', 'relax', 'panel_size', 'options')","(nan, None, None, None, None, {})","(nan, 'NoneType', 'NoneType', 'NoneType', 'NoneType', 'dict')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(A, permc_spec=None, diag_pivot_thresh=None, relax=None, panel_size=None, options={})',)"
scipy,1.1.0,scipy.integrate._ivp.radau.validate_max_step,integrate._ivp.radau,validate_max_step,"Python Library Documentation: function validate_max_step in module scipy.integrate._ivp.common

validate_max_step(max_step)
    Assert that max_Step is valid and return it.
",function,"('(max_step)',)",scipy,1.1.0,scipy.integrate._ivp.radau.validate_max_step,integrate._ivp.radau,validate_max_step,"Python Library Documentation: function validate_max_step in module scipy.integrate._ivp.common

validate_max_step(max_step)
    Assert that max_Step is valid and return it.
",function,"('max_step',)","(nan,)","(nan,)","('arg_info',)","('(max_step)',)"
scipy,1.1.0,scipy.integrate._ivp.radau.validate_tol,integrate._ivp.radau,validate_tol,"Python Library Documentation: function validate_tol in module scipy.integrate._ivp.common

validate_tol(rtol, atol, n)
    Validate tolerance values.
",function,"('(rtol, atol, n)',)",scipy,1.1.0,scipy.integrate._ivp.radau.validate_tol,integrate._ivp.radau,validate_tol,"Python Library Documentation: function validate_tol in module scipy.integrate._ivp.common

validate_tol(rtol, atol, n)
    Validate tolerance values.
",function,"('rtol', 'atol', 'n')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(rtol, atol, n)',)"
scipy,1.1.0,scipy.integrate._ivp.radau.warn_extraneous,integrate._ivp.radau,warn_extraneous,"Python Library Documentation: function warn_extraneous in module scipy.integrate._ivp.common

warn_extraneous(extraneous)
    Display a warning for extraneous keyword arguments.
    
    The initializer of each solver class is expected to collect keyword
    arguments that it doesn't understand and warn about them. This function
    prints a warning for each key in the supplied dictionary.
    
    Parameters
    ----------
    extraneous : dict
        Extraneous keyword arguments
",function,"('(extraneous)',)",scipy,1.1.0,scipy.integrate._ivp.radau.warn_extraneous,integrate._ivp.radau,warn_extraneous,"Python Library Documentation: function warn_extraneous in module scipy.integrate._ivp.common

warn_extraneous(extraneous)
    Display a warning for extraneous keyword arguments.
    
    The initializer of each solver class is expected to collect keyword
    arguments that it doesn't understand and warn about them. This function
    prints a warning for each key in the supplied dictionary.
    
    Parameters
    ----------
    extraneous : dict
        Extraneous keyword arguments
",function,"('extraneous',)","(nan,)","(nan,)","('arg_info',)","('(extraneous)',)"
scipy,1.1.0,scipy.integrate._ivp.rk.DenseOutput,integrate._ivp.rk,DenseOutput,"Python Library Documentation: class DenseOutput in module scipy.integrate._ivp.base

class DenseOutput(builtins.object)
 |  Base class for local interpolant over step made by an ODE solver.
 |  
 |  It interpolates between `t_min` and `t_max` (see Attributes below).
 |  Evaluation outside this interval is not forbidden, but the accuracy is not
 |  guaranteed.
 |  
 |  Attributes
 |  ----------
 |  t_min, t_max : float
 |      Time range of the interpolation.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, t)
 |      Evaluate the interpolant.
 |      
 |      Parameters
 |      ----------
 |      t : float or array_like with shape (n_points,)
 |          Points to evaluate the solution at.
 |      
 |      Returns
 |      -------
 |      y : ndarray, shape (n,) or (n, n_points)
 |          Computed values. Shape depends on whether `t` was a scalar or a
 |          1-d array.
 |  
 |  __init__(self, t_old, t)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, t_old, t)',)",scipy,1.1.0,scipy.integrate._ivp.rk.DenseOutput,integrate._ivp.rk,DenseOutput,"Python Library Documentation: class DenseOutput in module scipy.integrate._ivp.base

class DenseOutput(builtins.object)
 |  Base class for local interpolant over step made by an ODE solver.
 |  
 |  It interpolates between `t_min` and `t_max` (see Attributes below).
 |  Evaluation outside this interval is not forbidden, but the accuracy is not
 |  guaranteed.
 |  
 |  Attributes
 |  ----------
 |  t_min, t_max : float
 |      Time range of the interpolation.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, t)
 |      Evaluate the interpolant.
 |      
 |      Parameters
 |      ----------
 |      t : float or array_like with shape (n_points,)
 |          Points to evaluate the solution at.
 |      
 |      Returns
 |      -------
 |      y : ndarray, shape (n,) or (n, n_points)
 |          Computed values. Shape depends on whether `t` was a scalar or a
 |          1-d array.
 |  
 |  __init__(self, t_old, t)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 't_old', 't')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(self, t_old, t)',)"
scipy,1.1.0,scipy.integrate._ivp.rk.OdeSolver,integrate._ivp.rk,OdeSolver,"Python Library Documentation: class OdeSolver in module scipy.integrate._ivp.base

class OdeSolver(builtins.object)
 |  Base class for ODE solvers.
 |  
 |  In order to implement a new solver you need to follow the guidelines:
 |  
 |      1. A constructor must accept parameters presented in the base class
 |         (listed below) along with any other parameters specific to a solver.
 |      2. A constructor must accept arbitrary extraneous arguments
 |         ``**extraneous``, but warn that these arguments are irrelevant
 |         using `common.warn_extraneous` function. Do not pass these
 |         arguments to the base class.
 |      3. A solver must implement a private method `_step_impl(self)` which
 |         propagates a solver one step further. It must return tuple
 |         ``(success, message)``, where ``success`` is a boolean indicating
 |         whether a step was successful, and ``message`` is a string
 |         containing description of a failure if a step failed or None
 |         otherwise.
 |      4. A solver must implement a private method `_dense_output_impl(self)`
 |         which returns a `DenseOutput` object covering the last successful
 |         step.
 |      5. A solver must have attributes listed below in Attributes section.
 |         Note that `t_old` and `step_size` are updated automatically.
 |      6. Use `fun(self, t, y)` method for the system rhs evaluation, this
 |         way the number of function evaluations (`nfev`) will be tracked
 |         automatically.
 |      7. For convenience a base class provides `fun_single(self, t, y)` and
 |         `fun_vectorized(self, t, y)` for evaluating the rhs in
 |         non-vectorized and vectorized fashions respectively (regardless of
 |         how `fun` from the constructor is implemented). These calls don't
 |         increment `nfev`.
 |      8. If a solver uses a Jacobian matrix and LU decompositions, it should
 |         track the number of Jacobian evaluations (`njev`) and the number of
 |         LU decompositions (`nlu`).
 |      9. By convention the function evaluations used to compute a finite
 |         difference approximation of the Jacobian should not be counted in
 |         `nfev`, thus use `fun_single(self, t, y)` or
 |         `fun_vectorized(self, t, y)` when computing a finite difference
 |         approximation of the Jacobian.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar and there are two options for ndarray ``y``.
 |      It can either have shape (n,), then ``fun`` must return array_like with
 |      shape (n,). Or alternatively it can have shape (n, n_points), then
 |      ``fun`` must return array_like with shape (n, n_points) (each column
 |      corresponds to a single column in ``y``). The choice between the two
 |      options is determined by `vectorized` argument (see below).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time --- the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  vectorized : bool
 |      Whether `fun` is implemented in a vectorized fashion.
 |  support_complex : bool, optional
 |      Whether integration in a complex domain should be supported.
 |      Generally determined by a derived solver class capabilities.
 |      Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number of the system's rhs evaluations.
 |  njev : int
 |      Number of the Jacobian evaluations.
 |  nlu : int
 |      Number of LU decompositions.
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, vectorized, support_complex=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('(self, fun, t0, y0, t_bound, vectorized, support_complex=False)',)",scipy,1.1.0,scipy.integrate._ivp.rk.OdeSolver,integrate._ivp.rk,OdeSolver,"Python Library Documentation: class OdeSolver in module scipy.integrate._ivp.base

class OdeSolver(builtins.object)
 |  Base class for ODE solvers.
 |  
 |  In order to implement a new solver you need to follow the guidelines:
 |  
 |      1. A constructor must accept parameters presented in the base class
 |         (listed below) along with any other parameters specific to a solver.
 |      2. A constructor must accept arbitrary extraneous arguments
 |         ``**extraneous``, but warn that these arguments are irrelevant
 |         using `common.warn_extraneous` function. Do not pass these
 |         arguments to the base class.
 |      3. A solver must implement a private method `_step_impl(self)` which
 |         propagates a solver one step further. It must return tuple
 |         ``(success, message)``, where ``success`` is a boolean indicating
 |         whether a step was successful, and ``message`` is a string
 |         containing description of a failure if a step failed or None
 |         otherwise.
 |      4. A solver must implement a private method `_dense_output_impl(self)`
 |         which returns a `DenseOutput` object covering the last successful
 |         step.
 |      5. A solver must have attributes listed below in Attributes section.
 |         Note that `t_old` and `step_size` are updated automatically.
 |      6. Use `fun(self, t, y)` method for the system rhs evaluation, this
 |         way the number of function evaluations (`nfev`) will be tracked
 |         automatically.
 |      7. For convenience a base class provides `fun_single(self, t, y)` and
 |         `fun_vectorized(self, t, y)` for evaluating the rhs in
 |         non-vectorized and vectorized fashions respectively (regardless of
 |         how `fun` from the constructor is implemented). These calls don't
 |         increment `nfev`.
 |      8. If a solver uses a Jacobian matrix and LU decompositions, it should
 |         track the number of Jacobian evaluations (`njev`) and the number of
 |         LU decompositions (`nlu`).
 |      9. By convention the function evaluations used to compute a finite
 |         difference approximation of the Jacobian should not be counted in
 |         `nfev`, thus use `fun_single(self, t, y)` or
 |         `fun_vectorized(self, t, y)` when computing a finite difference
 |         approximation of the Jacobian.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar and there are two options for ndarray ``y``.
 |      It can either have shape (n,), then ``fun`` must return array_like with
 |      shape (n,). Or alternatively it can have shape (n, n_points), then
 |      ``fun`` must return array_like with shape (n, n_points) (each column
 |      corresponds to a single column in ``y``). The choice between the two
 |      options is determined by `vectorized` argument (see below).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time --- the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  vectorized : bool
 |      Whether `fun` is implemented in a vectorized fashion.
 |  support_complex : bool, optional
 |      Whether integration in a complex domain should be supported.
 |      Generally determined by a derived solver class capabilities.
 |      Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number of the system's rhs evaluations.
 |  njev : int
 |      Number of the Jacobian evaluations.
 |  nlu : int
 |      Number of LU decompositions.
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, vectorized, support_complex=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('self', 'fun', 't0', 'y0', 't_bound', 'vectorized', 'support_complex')","(nan, nan, nan, nan, nan, nan, False)","(nan, nan, nan, nan, nan, nan, 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, fun, t0, y0, t_bound, vectorized, support_complex=False)',)"
scipy,1.1.0,scipy.integrate._ivp.rk.RK23,integrate._ivp.rk,RK23,"Python Library Documentation: class RK23 in module scipy.integrate._ivp.rk

class RK23(RungeKutta)
 |  Explicit Runge-Kutta method of order 3(2).
 |  
 |  This uses the Bogacki-Shampine pair of formulas [1]_. The error is controlled
 |  assuming accuracy of the second-order method, but steps are taken using the
 |  third-order accurate formula (local extrapolation is done). A cubic Hermite
 |  polynomial is used for the dense output.
 |  
 |  Can be applied in the complex domain.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar and there are two options for ndarray ``y``.
 |      It can either have shape (n,), then ``fun`` must return array_like with
 |      shape (n,). Or alternatively it can have shape (n, k), then ``fun``
 |      must return array_like with shape (n, k), i.e. each column
 |      corresponds to a single column in ``y``. The choice between the two
 |      options is determined by `vectorized` argument (see below).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time - the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  max_step : float, optional
 |      Maximum allowed step size. Default is np.inf, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  rtol, atol : float and array_like, optional
 |      Relative and absolute tolerances. The solver keeps the local error
 |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
 |      relative accuracy (number of correct digits). But if a component of `y`
 |      is approximately below `atol`, the error only needs to fall within
 |      the same `atol` threshold, and the number of correct digits is not
 |      guaranteed. If components of y have different scales, it might be
 |      beneficial to set different `atol` values for different components by
 |      passing array_like with shape (n,) for `atol`. Default values are
 |      1e-3 for `rtol` and 1e-6 for `atol`.
 |  vectorized : bool, optional
 |      Whether `fun` is implemented in a vectorized fashion. Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number evaluations of the system's right-hand side.
 |  njev : int
 |      Number of evaluations of the Jacobian. Is always 0 for this solver as it does not use the Jacobian.
 |  nlu : int
 |      Number of LU decompositions. Is always 0 for this solver.
 |  
 |  References
 |  ----------
 |  .. [1] P. Bogacki, L.F. Shampine, ""A 3(2) Pair of Runge-Kutta Formulas"",
 |         Appl. Math. Lett. Vol. 2, No. 4. pp. 321-325, 1989.
 |  
 |  Method resolution order:
 |      RK23
 |      RungeKutta
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Data and other attributes defined here:
 |  
 |  A = [array([0.5]), array([0.  , 0.75])]
 |  
 |  B = array([0.22222222, 0.33333333, 0.44444444])
 |  
 |  C = array([0.5 , 0.75])
 |  
 |  E = array([ 0.06944444, -0.08333333, -0.11111111,  0.125     ])
 |  
 |  P = array([[ 1.        , -1.33333333,  0.55555556],
 |  ...
 |         [ 0.   ...
 |  
 |  n_stages = 3
 |  
 |  order = 2
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from RungeKutta:
 |  
 |  __init__(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, vectorized=False, **extraneous)',)",scipy,1.1.0,scipy.integrate._ivp.rk.RK23,integrate._ivp.rk,RK23,"Python Library Documentation: class RK23 in module scipy.integrate._ivp.rk

class RK23(RungeKutta)
 |  Explicit Runge-Kutta method of order 3(2).
 |  
 |  This uses the Bogacki-Shampine pair of formulas [1]_. The error is controlled
 |  assuming accuracy of the second-order method, but steps are taken using the
 |  third-order accurate formula (local extrapolation is done). A cubic Hermite
 |  polynomial is used for the dense output.
 |  
 |  Can be applied in the complex domain.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar and there are two options for ndarray ``y``.
 |      It can either have shape (n,), then ``fun`` must return array_like with
 |      shape (n,). Or alternatively it can have shape (n, k), then ``fun``
 |      must return array_like with shape (n, k), i.e. each column
 |      corresponds to a single column in ``y``. The choice between the two
 |      options is determined by `vectorized` argument (see below).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time - the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  max_step : float, optional
 |      Maximum allowed step size. Default is np.inf, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  rtol, atol : float and array_like, optional
 |      Relative and absolute tolerances. The solver keeps the local error
 |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
 |      relative accuracy (number of correct digits). But if a component of `y`
 |      is approximately below `atol`, the error only needs to fall within
 |      the same `atol` threshold, and the number of correct digits is not
 |      guaranteed. If components of y have different scales, it might be
 |      beneficial to set different `atol` values for different components by
 |      passing array_like with shape (n,) for `atol`. Default values are
 |      1e-3 for `rtol` and 1e-6 for `atol`.
 |  vectorized : bool, optional
 |      Whether `fun` is implemented in a vectorized fashion. Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number evaluations of the system's right-hand side.
 |  njev : int
 |      Number of evaluations of the Jacobian. Is always 0 for this solver as it does not use the Jacobian.
 |  nlu : int
 |      Number of LU decompositions. Is always 0 for this solver.
 |  
 |  References
 |  ----------
 |  .. [1] P. Bogacki, L.F. Shampine, ""A 3(2) Pair of Runge-Kutta Formulas"",
 |         Appl. Math. Lett. Vol. 2, No. 4. pp. 321-325, 1989.
 |  
 |  Method resolution order:
 |      RK23
 |      RungeKutta
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Data and other attributes defined here:
 |  
 |  A = [array([0.5]), array([0.  , 0.75])]
 |  
 |  B = array([0.22222222, 0.33333333, 0.44444444])
 |  
 |  C = array([0.5 , 0.75])
 |  
 |  E = array([ 0.06944444, -0.08333333, -0.11111111,  0.125     ])
 |  
 |  P = array([[ 1.        , -1.33333333,  0.55555556],
 |  ...
 |         [ 0.   ...
 |  
 |  n_stages = 3
 |  
 |  order = 2
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from RungeKutta:
 |  
 |  __init__(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('self', 'fun', 't0', 'y0', 't_bound', 'max_step', 'rtol', 'atol', 'vectorized')","(nan, nan, nan, nan, nan, inf, 0.001, 1e-06, False)","(nan, nan, nan, nan, nan, 'float', 'float', 'float', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, vectorized=False, **extraneous)',)"
scipy,1.1.0,scipy.integrate._ivp.rk.RK45,integrate._ivp.rk,RK45,"Python Library Documentation: class RK45 in module scipy.integrate._ivp.rk

class RK45(RungeKutta)
 |  Explicit Runge-Kutta method of order 5(4).
 |  
 |  This uses the Dormand-Prince pair of formulas [1]_. The error is controlled
 |  assuming accuracy of the fourth-order method accuracy, but steps are taken
 |  using the fifth-order accurate formula (local extrapolation is done).
 |  A quartic interpolation polynomial is used for the dense output [2]_.
 |  
 |  Can be applied in the complex domain.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar, and there are two options for the ndarray ``y``:
 |      It can either have shape (n,); then ``fun`` must return array_like with
 |      shape (n,). Alternatively it can have shape (n, k); then ``fun``
 |      must return an array_like with shape (n, k), i.e. each column
 |      corresponds to a single column in ``y``. The choice between the two
 |      options is determined by `vectorized` argument (see below).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time - the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  max_step : float, optional
 |      Maximum allowed step size. Default is np.inf, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  rtol, atol : float and array_like, optional
 |      Relative and absolute tolerances. The solver keeps the local error
 |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
 |      relative accuracy (number of correct digits). But if a component of `y`
 |      is approximately below `atol`, the error only needs to fall within
 |      the same `atol` threshold, and the number of correct digits is not
 |      guaranteed. If components of y have different scales, it might be
 |      beneficial to set different `atol` values for different components by
 |      passing array_like with shape (n,) for `atol`. Default values are
 |      1e-3 for `rtol` and 1e-6 for `atol`.
 |  vectorized : bool, optional
 |      Whether `fun` is implemented in a vectorized fashion. Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number evaluations of the system's right-hand side.
 |  njev : int
 |      Number of evaluations of the Jacobian. Is always 0 for this solver as it does not use the Jacobian.
 |  nlu : int
 |      Number of LU decompositions. Is always 0 for this solver.
 |  
 |  References
 |  ----------
 |  .. [1] J. R. Dormand, P. J. Prince, ""A family of embedded Runge-Kutta
 |         formulae"", Journal of Computational and Applied Mathematics, Vol. 6,
 |         No. 1, pp. 19-26, 1980.
 |  .. [2] L. W. Shampine, ""Some Practical Runge-Kutta Formulas"", Mathematics
 |         of Computation,, Vol. 46, No. 173, pp. 135-150, 1986.
 |  
 |  Method resolution order:
 |      RK45
 |      RungeKutta
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Data and other attributes defined here:
 |  
 |  A = [array([0.2]), array([0.075, 0.225]), array([ 0.97777778, -3.73333...
 |  
 |  B = array([ 0.09114583,  0.        ,  0.4492363 ,  0.65104167, -0.3223...
 |  
 |  C = array([0.2       , 0.3       , 0.8       , 0.88888889, 1.        ]...
 |  
 |  E = array([-0.00123264,  0.        ,  0.00425277, -0...7,  0.0508638 ,...
 |  
 |  P = array([[ 1.        , -2.85358007,  3.07174346, -...       ,  1.382...
 |  
 |  n_stages = 6
 |  
 |  order = 4
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from RungeKutta:
 |  
 |  __init__(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, vectorized=False, **extraneous)',)",scipy,1.1.0,scipy.integrate._ivp.rk.RK45,integrate._ivp.rk,RK45,"Python Library Documentation: class RK45 in module scipy.integrate._ivp.rk

class RK45(RungeKutta)
 |  Explicit Runge-Kutta method of order 5(4).
 |  
 |  This uses the Dormand-Prince pair of formulas [1]_. The error is controlled
 |  assuming accuracy of the fourth-order method accuracy, but steps are taken
 |  using the fifth-order accurate formula (local extrapolation is done).
 |  A quartic interpolation polynomial is used for the dense output [2]_.
 |  
 |  Can be applied in the complex domain.
 |  
 |  Parameters
 |  ----------
 |  fun : callable
 |      Right-hand side of the system. The calling signature is ``fun(t, y)``.
 |      Here ``t`` is a scalar, and there are two options for the ndarray ``y``:
 |      It can either have shape (n,); then ``fun`` must return array_like with
 |      shape (n,). Alternatively it can have shape (n, k); then ``fun``
 |      must return an array_like with shape (n, k), i.e. each column
 |      corresponds to a single column in ``y``. The choice between the two
 |      options is determined by `vectorized` argument (see below).
 |  t0 : float
 |      Initial time.
 |  y0 : array_like, shape (n,)
 |      Initial state.
 |  t_bound : float
 |      Boundary time - the integration won't continue beyond it. It also
 |      determines the direction of the integration.
 |  max_step : float, optional
 |      Maximum allowed step size. Default is np.inf, i.e. the step size is not
 |      bounded and determined solely by the solver.
 |  rtol, atol : float and array_like, optional
 |      Relative and absolute tolerances. The solver keeps the local error
 |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
 |      relative accuracy (number of correct digits). But if a component of `y`
 |      is approximately below `atol`, the error only needs to fall within
 |      the same `atol` threshold, and the number of correct digits is not
 |      guaranteed. If components of y have different scales, it might be
 |      beneficial to set different `atol` values for different components by
 |      passing array_like with shape (n,) for `atol`. Default values are
 |      1e-3 for `rtol` and 1e-6 for `atol`.
 |  vectorized : bool, optional
 |      Whether `fun` is implemented in a vectorized fashion. Default is False.
 |  
 |  Attributes
 |  ----------
 |  n : int
 |      Number of equations.
 |  status : string
 |      Current status of the solver: 'running', 'finished' or 'failed'.
 |  t_bound : float
 |      Boundary time.
 |  direction : float
 |      Integration direction: +1 or -1.
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current state.
 |  t_old : float
 |      Previous time. None if no steps were made yet.
 |  step_size : float
 |      Size of the last successful step. None if no steps were made yet.
 |  nfev : int
 |      Number evaluations of the system's right-hand side.
 |  njev : int
 |      Number of evaluations of the Jacobian. Is always 0 for this solver as it does not use the Jacobian.
 |  nlu : int
 |      Number of LU decompositions. Is always 0 for this solver.
 |  
 |  References
 |  ----------
 |  .. [1] J. R. Dormand, P. J. Prince, ""A family of embedded Runge-Kutta
 |         formulae"", Journal of Computational and Applied Mathematics, Vol. 6,
 |         No. 1, pp. 19-26, 1980.
 |  .. [2] L. W. Shampine, ""Some Practical Runge-Kutta Formulas"", Mathematics
 |         of Computation,, Vol. 46, No. 173, pp. 135-150, 1986.
 |  
 |  Method resolution order:
 |      RK45
 |      RungeKutta
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Data and other attributes defined here:
 |  
 |  A = [array([0.2]), array([0.075, 0.225]), array([ 0.97777778, -3.73333...
 |  
 |  B = array([ 0.09114583,  0.        ,  0.4492363 ,  0.65104167, -0.3223...
 |  
 |  C = array([0.2       , 0.3       , 0.8       , 0.88888889, 1.        ]...
 |  
 |  E = array([-0.00123264,  0.        ,  0.00425277, -0...7,  0.0508638 ,...
 |  
 |  P = array([[ 1.        , -2.85358007,  3.07174346, -...       ,  1.382...
 |  
 |  n_stages = 6
 |  
 |  order = 4
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from RungeKutta:
 |  
 |  __init__(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('self', 'fun', 't0', 'y0', 't_bound', 'max_step', 'rtol', 'atol', 'vectorized')","(nan, nan, nan, nan, nan, inf, 0.001, 1e-06, False)","(nan, nan, nan, nan, nan, 'float', 'float', 'float', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, vectorized=False, **extraneous)',)"
scipy,1.1.0,scipy.integrate._ivp.rk.RkDenseOutput,integrate._ivp.rk,RkDenseOutput,"Python Library Documentation: class RkDenseOutput in module scipy.integrate._ivp.rk

class RkDenseOutput(scipy.integrate._ivp.base.DenseOutput)
 |  Base class for local interpolant over step made by an ODE solver.
 |  
 |  It interpolates between `t_min` and `t_max` (see Attributes below).
 |  Evaluation outside this interval is not forbidden, but the accuracy is not
 |  guaranteed.
 |  
 |  Attributes
 |  ----------
 |  t_min, t_max : float
 |      Time range of the interpolation.
 |  
 |  Method resolution order:
 |      RkDenseOutput
 |      scipy.integrate._ivp.base.DenseOutput
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, t_old, t, y_old, Q)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.DenseOutput:
 |  
 |  __call__(self, t)
 |      Evaluate the interpolant.
 |      
 |      Parameters
 |      ----------
 |      t : float or array_like with shape (n_points,)
 |          Points to evaluate the solution at.
 |      
 |      Returns
 |      -------
 |      y : ndarray, shape (n,) or (n, n_points)
 |          Computed values. Shape depends on whether `t` was a scalar or a
 |          1-d array.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.DenseOutput:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, t_old, t, y_old, Q)',)",scipy,1.1.0,scipy.integrate._ivp.rk.RkDenseOutput,integrate._ivp.rk,RkDenseOutput,"Python Library Documentation: class RkDenseOutput in module scipy.integrate._ivp.rk

class RkDenseOutput(scipy.integrate._ivp.base.DenseOutput)
 |  Base class for local interpolant over step made by an ODE solver.
 |  
 |  It interpolates between `t_min` and `t_max` (see Attributes below).
 |  Evaluation outside this interval is not forbidden, but the accuracy is not
 |  guaranteed.
 |  
 |  Attributes
 |  ----------
 |  t_min, t_max : float
 |      Time range of the interpolation.
 |  
 |  Method resolution order:
 |      RkDenseOutput
 |      scipy.integrate._ivp.base.DenseOutput
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, t_old, t, y_old, Q)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.DenseOutput:
 |  
 |  __call__(self, t)
 |      Evaluate the interpolant.
 |      
 |      Parameters
 |      ----------
 |      t : float or array_like with shape (n_points,)
 |          Points to evaluate the solution at.
 |      
 |      Returns
 |      -------
 |      y : ndarray, shape (n,) or (n, n_points)
 |          Computed values. Shape depends on whether `t` was a scalar or a
 |          1-d array.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.DenseOutput:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 't_old', 't', 'y_old', 'Q')","(nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, t_old, t, y_old, Q)',)"
scipy,1.1.0,scipy.integrate._ivp.rk.RungeKutta,integrate._ivp.rk,RungeKutta,"Python Library Documentation: class RungeKutta in module scipy.integrate._ivp.rk

class RungeKutta(scipy.integrate._ivp.base.OdeSolver)
 |  Base class for explicit Runge-Kutta methods.
 |  
 |  Method resolution order:
 |      RungeKutta
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  A = NotImplemented
 |  
 |  B = NotImplemented
 |  
 |  C = NotImplemented
 |  
 |  E = NotImplemented
 |  
 |  P = NotImplemented
 |  
 |  n_stages = NotImplemented
 |  
 |  order = NotImplemented
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, vectorized=False, **extraneous)',)",scipy,1.1.0,scipy.integrate._ivp.rk.RungeKutta,integrate._ivp.rk,RungeKutta,"Python Library Documentation: class RungeKutta in module scipy.integrate._ivp.rk

class RungeKutta(scipy.integrate._ivp.base.OdeSolver)
 |  Base class for explicit Runge-Kutta methods.
 |  
 |  Method resolution order:
 |      RungeKutta
 |      scipy.integrate._ivp.base.OdeSolver
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, vectorized=False, **extraneous)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  A = NotImplemented
 |  
 |  B = NotImplemented
 |  
 |  C = NotImplemented
 |  
 |  E = NotImplemented
 |  
 |  P = NotImplemented
 |  
 |  n_stages = NotImplemented
 |  
 |  order = NotImplemented
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  dense_output(self)
 |      Compute a local interpolant over the last successful step.
 |      
 |      Returns
 |      -------
 |      sol : `DenseOutput`
 |          Local interpolant over the last successful step.
 |  
 |  step(self)
 |      Perform one integration step.
 |      
 |      Returns
 |      -------
 |      message : string or None
 |          Report from the solver. Typically a reason for a failure if
 |          `self.status` is 'failed' after the step was taken or None
 |          otherwise.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  step_size
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:
 |  
 |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...
",class,"('self', 'fun', 't0', 'y0', 't_bound', 'max_step', 'rtol', 'atol', 'vectorized')","(nan, nan, nan, nan, nan, inf, 0.001, 1e-06, False)","(nan, nan, nan, nan, nan, 'float', 'float', 'float', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, vectorized=False, **extraneous)',)"
scipy,1.1.0,scipy.integrate._ivp.rk.norm,integrate._ivp.rk,norm,"Python Library Documentation: function norm in module scipy.integrate._ivp.common

norm(x)
    Compute RMS norm.
",function,"('(x)',)",scipy,1.1.0,scipy.integrate._ivp.rk.norm,integrate._ivp.rk,norm,"Python Library Documentation: function norm in module scipy.integrate._ivp.common

norm(x)
    Compute RMS norm.
",function,"('x',)","(nan,)","(nan,)","('arg_info',)","('(x)',)"
scipy,1.1.0,scipy.integrate._ivp.rk.rk_step,integrate._ivp.rk,rk_step,"Python Library Documentation: function rk_step in module scipy.integrate._ivp.rk

rk_step(fun, t, y, f, h, A, B, C, E, K)
    Perform a single Runge-Kutta step.
    
    This function computes a prediction of an explicit Runge-Kutta method and
    also estimates the error of a less accurate method.
    
    Notation for Butcher tableau is as in [1]_.
    
    Parameters
    ----------
    fun : callable
        Right-hand side of the system.
    t : float
        Current time.
    y : ndarray, shape (n,)
        Current state.
    f : ndarray, shape (n,)
        Current value of the derivative, i.e. ``fun(x, y)``.
    h : float
        Step to use.
    A : list of ndarray, length n_stages - 1
        Coefficients for combining previous RK stages to compute the next
        stage. For explicit methods the coefficients above the main diagonal
        are zeros, so `A` is stored as a list of arrays of increasing lengths.
        The first stage is always just `f`, thus no coefficients for it
        are required.
    B : ndarray, shape (n_stages,)
        Coefficients for combining RK stages for computing the final
        prediction.
    C : ndarray, shape (n_stages - 1,)
        Coefficients for incrementing time for consecutive RK stages.
        The value for the first stage is always zero, thus it is not stored.
    E : ndarray, shape (n_stages + 1,)
        Coefficients for estimating the error of a less accurate method. They
        are computed as the difference between b's in an extended tableau.
    K : ndarray, shape (n_stages + 1, n)
        Storage array for putting RK stages here. Stages are stored in rows.
    
    Returns
    -------
    y_new : ndarray, shape (n,)
        Solution at t + h computed with a higher accuracy.
    f_new : ndarray, shape (n,)
        Derivative ``fun(t + h, y_new)``.
    error : ndarray, shape (n,)
        Error estimate of a less accurate method.
    
    References
    ----------
    .. [1] E. Hairer, S. P. Norsett G. Wanner, ""Solving Ordinary Differential
           Equations I: Nonstiff Problems"", Sec. II.4.
",function,"('(fun, t, y, f, h, A, B, C, E, K)',)",scipy,1.1.0,scipy.integrate._ivp.rk.rk_step,integrate._ivp.rk,rk_step,"Python Library Documentation: function rk_step in module scipy.integrate._ivp.rk

rk_step(fun, t, y, f, h, A, B, C, E, K)
    Perform a single Runge-Kutta step.
    
    This function computes a prediction of an explicit Runge-Kutta method and
    also estimates the error of a less accurate method.
    
    Notation for Butcher tableau is as in [1]_.
    
    Parameters
    ----------
    fun : callable
        Right-hand side of the system.
    t : float
        Current time.
    y : ndarray, shape (n,)
        Current state.
    f : ndarray, shape (n,)
        Current value of the derivative, i.e. ``fun(x, y)``.
    h : float
        Step to use.
    A : list of ndarray, length n_stages - 1
        Coefficients for combining previous RK stages to compute the next
        stage. For explicit methods the coefficients above the main diagonal
        are zeros, so `A` is stored as a list of arrays of increasing lengths.
        The first stage is always just `f`, thus no coefficients for it
        are required.
    B : ndarray, shape (n_stages,)
        Coefficients for combining RK stages for computing the final
        prediction.
    C : ndarray, shape (n_stages - 1,)
        Coefficients for incrementing time for consecutive RK stages.
        The value for the first stage is always zero, thus it is not stored.
    E : ndarray, shape (n_stages + 1,)
        Coefficients for estimating the error of a less accurate method. They
        are computed as the difference between b's in an extended tableau.
    K : ndarray, shape (n_stages + 1, n)
        Storage array for putting RK stages here. Stages are stored in rows.
    
    Returns
    -------
    y_new : ndarray, shape (n,)
        Solution at t + h computed with a higher accuracy.
    f_new : ndarray, shape (n,)
        Derivative ``fun(t + h, y_new)``.
    error : ndarray, shape (n,)
        Error estimate of a less accurate method.
    
    References
    ----------
    .. [1] E. Hairer, S. P. Norsett G. Wanner, ""Solving Ordinary Differential
           Equations I: Nonstiff Problems"", Sec. II.4.
",function,"('fun', 't', 'y', 'f', 'h', 'A', 'B', 'C', 'E', 'K')","(nan, nan, nan, nan, nan, nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan, nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(fun, t, y, f, h, A, B, C, E, K)',)"
scipy,1.1.0,scipy.integrate._ivp.rk.select_initial_step,integrate._ivp.rk,select_initial_step,"Python Library Documentation: function select_initial_step in module scipy.integrate._ivp.common

select_initial_step(fun, t0, y0, f0, direction, order, rtol, atol)
    Empirically select a good initial step.
    
    The algorithm is described in [1]_.
    
    Parameters
    ----------
    fun : callable
        Right-hand side of the system.
    t0 : float
        Initial value of the independent variable.
    y0 : ndarray, shape (n,)
        Initial value of the dependent variable.
    f0 : ndarray, shape (n,)
        Initial value of the derivative, i. e. ``fun(t0, y0)``.
    direction : float
        Integration direction.
    order : float
        Method order.
    rtol : float
        Desired relative tolerance.
    atol : float
        Desired absolute tolerance.
    
    Returns
    -------
    h_abs : float
        Absolute value of the suggested initial step.
    
    References
    ----------
    .. [1] E. Hairer, S. P. Norsett G. Wanner, ""Solving Ordinary Differential
           Equations I: Nonstiff Problems"", Sec. II.4.
",function,"('(fun, t0, y0, f0, direction, order, rtol, atol)',)",scipy,1.1.0,scipy.integrate._ivp.rk.select_initial_step,integrate._ivp.rk,select_initial_step,"Python Library Documentation: function select_initial_step in module scipy.integrate._ivp.common

select_initial_step(fun, t0, y0, f0, direction, order, rtol, atol)
    Empirically select a good initial step.
    
    The algorithm is described in [1]_.
    
    Parameters
    ----------
    fun : callable
        Right-hand side of the system.
    t0 : float
        Initial value of the independent variable.
    y0 : ndarray, shape (n,)
        Initial value of the dependent variable.
    f0 : ndarray, shape (n,)
        Initial value of the derivative, i. e. ``fun(t0, y0)``.
    direction : float
        Integration direction.
    order : float
        Method order.
    rtol : float
        Desired relative tolerance.
    atol : float
        Desired absolute tolerance.
    
    Returns
    -------
    h_abs : float
        Absolute value of the suggested initial step.
    
    References
    ----------
    .. [1] E. Hairer, S. P. Norsett G. Wanner, ""Solving Ordinary Differential
           Equations I: Nonstiff Problems"", Sec. II.4.
",function,"('fun', 't0', 'y0', 'f0', 'direction', 'order', 'rtol', 'atol')","(nan, nan, nan, nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(fun, t0, y0, f0, direction, order, rtol, atol)',)"
scipy,1.1.0,scipy.integrate._ivp.rk.validate_max_step,integrate._ivp.rk,validate_max_step,"Python Library Documentation: function validate_max_step in module scipy.integrate._ivp.common

validate_max_step(max_step)
    Assert that max_Step is valid and return it.
",function,"('(max_step)',)",scipy,1.1.0,scipy.integrate._ivp.rk.validate_max_step,integrate._ivp.rk,validate_max_step,"Python Library Documentation: function validate_max_step in module scipy.integrate._ivp.common

validate_max_step(max_step)
    Assert that max_Step is valid and return it.
",function,"('max_step',)","(nan,)","(nan,)","('arg_info',)","('(max_step)',)"
scipy,1.1.0,scipy.integrate._ivp.rk.validate_tol,integrate._ivp.rk,validate_tol,"Python Library Documentation: function validate_tol in module scipy.integrate._ivp.common

validate_tol(rtol, atol, n)
    Validate tolerance values.
",function,"('(rtol, atol, n)',)",scipy,1.1.0,scipy.integrate._ivp.rk.validate_tol,integrate._ivp.rk,validate_tol,"Python Library Documentation: function validate_tol in module scipy.integrate._ivp.common

validate_tol(rtol, atol, n)
    Validate tolerance values.
",function,"('rtol', 'atol', 'n')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(rtol, atol, n)',)"
scipy,1.1.0,scipy.integrate._ivp.rk.warn_extraneous,integrate._ivp.rk,warn_extraneous,"Python Library Documentation: function warn_extraneous in module scipy.integrate._ivp.common

warn_extraneous(extraneous)
    Display a warning for extraneous keyword arguments.
    
    The initializer of each solver class is expected to collect keyword
    arguments that it doesn't understand and warn about them. This function
    prints a warning for each key in the supplied dictionary.
    
    Parameters
    ----------
    extraneous : dict
        Extraneous keyword arguments
",function,"('(extraneous)',)",scipy,1.1.0,scipy.integrate._ivp.rk.warn_extraneous,integrate._ivp.rk,warn_extraneous,"Python Library Documentation: function warn_extraneous in module scipy.integrate._ivp.common

warn_extraneous(extraneous)
    Display a warning for extraneous keyword arguments.
    
    The initializer of each solver class is expected to collect keyword
    arguments that it doesn't understand and warn about them. This function
    prints a warning for each key in the supplied dictionary.
    
    Parameters
    ----------
    extraneous : dict
        Extraneous keyword arguments
",function,"('extraneous',)","(nan,)","(nan,)","('arg_info',)","('(extraneous)',)"
scipy,1.1.0,scipy.integrate._ivp.solve_ivp,integrate._ivp,solve_ivp,"Python Library Documentation: function solve_ivp in module scipy.integrate._ivp.ivp

solve_ivp(fun, t_span, y0, method='RK45', t_eval=None, dense_output=False, events=None, vectorized=False, **options)
    Solve an initial value problem for a system of ODEs.
    
    This function numerically integrates a system of ordinary differential
    equations given an initial value::
    
        dy / dt = f(t, y)
        y(t0) = y0
    
    Here t is a one-dimensional independent variable (time), y(t) is an
    n-dimensional vector-valued function (state), and an n-dimensional
    vector-valued function f(t, y) determines the differential equations.
    The goal is to find y(t) approximately satisfying the differential
    equations, given an initial value y(t0)=y0.
    
    Some of the solvers support integration in the complex domain, but note that
    for stiff ODE solvers, the right-hand side must be complex-differentiable
    (satisfy Cauchy-Riemann equations [11]_). To solve a problem in the complex
    domain, pass y0 with a complex data type. Another option is always to
    rewrite your problem for real and imaginary parts separately.
    
    Parameters
    ----------
    fun : callable
        Right-hand side of the system. The calling signature is ``fun(t, y)``.
        Here ``t`` is a scalar, and there are two options for the ndarray ``y``:
        It can either have shape (n,); then ``fun`` must return array_like with
        shape (n,). Alternatively it can have shape (n, k); then ``fun``
        must return an array_like with shape (n, k), i.e. each column
        corresponds to a single column in ``y``. The choice between the two
        options is determined by `vectorized` argument (see below). The
        vectorized implementation allows a faster approximation of the Jacobian
        by finite differences (required for stiff solvers).
    t_span : 2-tuple of floats
        Interval of integration (t0, tf). The solver starts with t=t0 and
        integrates until it reaches t=tf.
    y0 : array_like, shape (n,)
        Initial state. For problems in the complex domain, pass `y0` with a
        complex data type (even if the initial guess is purely real).
    method : string or `OdeSolver`, optional
        Integration method to use:
    
            * 'RK45' (default): Explicit Runge-Kutta method of order 5(4) [1]_.
              The error is controlled assuming accuracy of the fourth-order
              method, but steps are taken using the fifth-order accurate formula
              (local extrapolation is done). A quartic interpolation polynomial
              is used for the dense output [2]_. Can be applied in the complex domain.
            * 'RK23': Explicit Runge-Kutta method of order 3(2) [3]_. The error
              is controlled assuming accuracy of the second-order method, but
              steps are taken using the third-order accurate formula (local
              extrapolation is done). A cubic Hermite polynomial is used for the
              dense output. Can be applied in the complex domain.
            * 'Radau': Implicit Runge-Kutta method of the Radau IIA family of
              order 5 [4]_. The error is controlled with a third-order accurate
              embedded formula. A cubic polynomial which satisfies the
              collocation conditions is used for the dense output.
            * 'BDF': Implicit multi-step variable-order (1 to 5) method based
              on a backward differentiation formula for the derivative
              approximation [5]_. The implementation follows the one described
              in [6]_. A quasi-constant step scheme is used and accuracy is
              enhanced using the NDF modification. Can be applied in the complex
              domain.
            * 'LSODA': Adams/BDF method with automatic stiffness detection and
              switching [7]_, [8]_. This is a wrapper of the Fortran solver
              from ODEPACK.
    
        You should use the 'RK45' or 'RK23' method for non-stiff problems and
        'Radau' or 'BDF' for stiff problems [9]_. If not sure, first try to run
        'RK45'. If needs unusually many iterations, diverges, or fails, your
        problem is likely to be stiff and you should use 'Radau' or 'BDF'.
        'LSODA' can also be a good universal choice, but it might be somewhat
        less convenient to work with as it wraps old Fortran code.
    
        You can also pass an arbitrary class derived from `OdeSolver` which
        implements the solver.
    dense_output : bool, optional
        Whether to compute a continuous solution. Default is False.
    t_eval : array_like or None, optional
        Times at which to store the computed solution, must be sorted and lie
        within `t_span`. If None (default), use points selected by the solver.
    events : callable, list of callables or None, optional
        Types of events to track. Each is defined by a continuous function of
        time and state that becomes zero value in case of an event. Each function
        must have the signature ``event(t, y)`` and return a float. The solver will
        find an accurate value of ``t`` at which ``event(t, y(t)) = 0`` using a
        root-finding algorithm. Additionally each ``event`` function might have
        the following attributes:
    
            * terminal: bool, whether to terminate integration if this
              event occurs. Implicitly False if not assigned.
            * direction: float, direction of a zero crossing. If `direction`
              is positive, `event` must go from negative to positive, and
              vice versa if `direction` is negative. If 0, then either direction
              will count. Implicitly 0 if not assigned.
    
        You can assign attributes like ``event.terminal = True`` to any
        function in Python. If None (default), events won't be tracked.
    vectorized : bool, optional
        Whether `fun` is implemented in a vectorized fashion. Default is False.
    options
        Options passed to a chosen solver. All options available for already
        implemented solvers are listed below.
    max_step : float, optional
        Maximum allowed step size. Default is np.inf, i.e. the step size is not
        bounded and determined solely by the solver.
    rtol, atol : float and array_like, optional
        Relative and absolute tolerances. The solver keeps the local error
        estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
        relative accuracy (number of correct digits). But if a component of `y`
        is approximately below `atol`, the error only needs to fall within
        the same `atol` threshold, and the number of correct digits is not
        guaranteed. If components of y have different scales, it might be
        beneficial to set different `atol` values for different components by
        passing array_like with shape (n,) for `atol`. Default values are
        1e-3 for `rtol` and 1e-6 for `atol`.
    jac : {None, array_like, sparse_matrix, callable}, optional
        Jacobian matrix of the right-hand side of the system with respect to
        y, required by the 'Radau', 'BDF' and 'LSODA' method. The Jacobian matrix
        has shape (n, n) and its element (i, j) is equal to ``d f_i / d y_j``.
        There are three ways to define the Jacobian:
    
            * If array_like or sparse_matrix, the Jacobian is assumed to
              be constant. Not supported by 'LSODA'.
            * If callable, the Jacobian is assumed to depend on both
              t and y; it will be called as ``jac(t, y)`` as necessary.
              For the 'Radau' and 'BDF' methods, the return value might be a
              sparse matrix.
            * If None (default), the Jacobian will be approximated by
              finite differences.
    
        It is generally recommended to provide the Jacobian rather than
        relying on a finite-difference approximation.
    jac_sparsity : {None, array_like, sparse matrix}, optional
        Defines a sparsity structure of the Jacobian matrix for a
        finite-difference approximation. Its shape must be (n, n). This argument
        is ignored if `jac` is not `None`. If the Jacobian has only few non-zero
        elements in *each* row, providing the sparsity structure will greatly
        speed up the computations [10]_. A zero entry means that a corresponding
        element in the Jacobian is always zero. If None (default), the Jacobian
        is assumed to be dense.
        Not supported by 'LSODA', see `lband` and `uband` instead.
    lband, uband : int or None
        Parameters defining the bandwidth of the Jacobian for the 'LSODA' method,
        i.e., ``jac[i, j] != 0 only for i - lband <= j <= i + uband``. Setting
        these requires your jac routine to return the Jacobian in the packed format:
        the returned array must have ``n`` columns and ``uband + lband + 1``
        rows in which Jacobian diagonals are written. Specifically
        ``jac_packed[uband + i - j , j] = jac[i, j]``. The same format is used
        in `scipy.linalg.solve_banded` (check for an illustration).
        These parameters can be also used with ``jac=None`` to reduce the
        number of Jacobian elements estimated by finite differences.
    min_step, first_step : float, optional
        The minimum allowed step size and the initial step size respectively
        for 'LSODA' method. By default `min_step` is zero and `first_step` is
        selected automatically.
    
    Returns
    -------
    Bunch object with the following fields defined:
    t : ndarray, shape (n_points,)
        Time points.
    y : ndarray, shape (n, n_points)
        Values of the solution at `t`.
    sol : `OdeSolution` or None
        Found solution as `OdeSolution` instance; None if `dense_output` was
        set to False.
    t_events : list of ndarray or None
        Contains for each event type a list of arrays at which an event of
        that type event was detected. None if `events` was None.
    nfev : int
        Number of evaluations of the right-hand side.
    njev : int
        Number of evaluations of the Jacobian.
    nlu : int
        Number of LU decompositions.
    status : int
        Reason for algorithm termination:
    
            * -1: Integration step failed.
            *  0: The solver successfully reached the end of `tspan`.
            *  1: A termination event occurred.
    
    message : string
        Human-readable description of the termination reason.
    success : bool
        True if the solver reached the interval end or a termination event
        occurred (``status >= 0``).
    
    References
    ----------
    .. [1] J. R. Dormand, P. J. Prince, ""A family of embedded Runge-Kutta
           formulae"", Journal of Computational and Applied Mathematics, Vol. 6,
           No. 1, pp. 19-26, 1980.
    .. [2] L. W. Shampine, ""Some Practical Runge-Kutta Formulas"", Mathematics
           of Computation,, Vol. 46, No. 173, pp. 135-150, 1986.
    .. [3] P. Bogacki, L.F. Shampine, ""A 3(2) Pair of Runge-Kutta Formulas"",
           Appl. Math. Lett. Vol. 2, No. 4. pp. 321-325, 1989.
    .. [4] E. Hairer, G. Wanner, ""Solving Ordinary Differential Equations II:
           Stiff and Differential-Algebraic Problems"", Sec. IV.8.
    .. [5] `Backward Differentiation Formula
            <https://en.wikipedia.org/wiki/Backward_differentiation_formula>`_
            on Wikipedia.
    .. [6] L. F. Shampine, M. W. Reichelt, ""THE MATLAB ODE SUITE"", SIAM J. SCI.
           COMPUTE., Vol. 18, No. 1, pp. 1-22, January 1997.
    .. [7] A. C. Hindmarsh, ""ODEPACK, A Systematized Collection of ODE
           Solvers,"" IMACS Transactions on Scientific Computation, Vol 1.,
           pp. 55-64, 1983.
    .. [8] L. Petzold, ""Automatic selection of methods for solving stiff and
           nonstiff systems of ordinary differential equations"", SIAM Journal
           on Scientific and Statistical Computing, Vol. 4, No. 1, pp. 136-148,
           1983.
    .. [9] `Stiff equation <https://en.wikipedia.org/wiki/Stiff_equation>`_ on
           Wikipedia.
    .. [10] A. Curtis, M. J. D. Powell, and J. Reid, ""On the estimation of
            sparse Jacobian matrices"", Journal of the Institute of Mathematics
            and its Applications, 13, pp. 117-120, 1974.
    .. [11] `Cauchy-Riemann equations
             <https://en.wikipedia.org/wiki/Cauchy-Riemann_equations>`_ on
             Wikipedia.
    
    Examples
    --------
    Basic exponential decay showing automatically chosen time points.
    
    >>> from scipy.integrate import solve_ivp
    >>> def exponential_decay(t, y): return -0.5 * y
    >>> sol = solve_ivp(exponential_decay, [0, 10], [2, 4, 8])
    >>> print(sol.t)
    [  0.           0.11487653   1.26364188   3.06061781   4.85759374
       6.65456967   8.4515456   10.        ]
    >>> print(sol.y)
    [[2.         1.88836035 1.06327177 0.43319312 0.17648948 0.0719045
      0.02929499 0.01350938]
     [4.         3.7767207  2.12654355 0.86638624 0.35297895 0.143809
      0.05858998 0.02701876]
     [8.         7.5534414  4.25308709 1.73277247 0.7059579  0.287618
      0.11717996 0.05403753]]
    
    Specifying points where the solution is desired.
    
    >>> sol = solve_ivp(exponential_decay, [0, 10], [2, 4, 8],
    ...                 t_eval=[0, 1, 2, 4, 10])
    >>> print(sol.t)
    [ 0  1  2  4 10]
    >>> print(sol.y)
    [[2.         1.21305369 0.73534021 0.27066736 0.01350938]
     [4.         2.42610739 1.47068043 0.54133472 0.02701876]
     [8.         4.85221478 2.94136085 1.08266944 0.05403753]]
    
    Cannon fired upward with terminal event upon impact. The ``terminal`` and
    ``direction`` fields of an event are applied by monkey patching a function.
    Here ``y[0]`` is position and ``y[1]`` is velocity. The projectile starts at
    position 0 with velocity +10. Note that the integration never reaches t=100
    because the event is terminal.
    
    >>> def upward_cannon(t, y): return [y[1], -0.5]
    >>> def hit_ground(t, y): return y[1]
    >>> hit_ground.terminal = True
    >>> hit_ground.direction = -1
    >>> sol = solve_ivp(upward_cannon, [0, 100], [0, 10], events=hit_ground)
    >>> print(sol.t_events)
    [array([ 20.])]
    >>> print(sol.t)
    [0.00000000e+00 9.99900010e-05 1.09989001e-03 1.10988901e-02
     1.11088891e-01 1.11098890e+00 1.11099890e+01 2.00000000e+01]
",function,"(""(fun, t_span, y0, method='RK45', t_eval=None, dense_output=False, events=None, vectorized=False, **options)"",)",scipy,1.1.0,scipy.integrate._ivp.solve_ivp,integrate._ivp,solve_ivp,"Python Library Documentation: function solve_ivp in module scipy.integrate._ivp.ivp

solve_ivp(fun, t_span, y0, method='RK45', t_eval=None, dense_output=False, events=None, vectorized=False, **options)
    Solve an initial value problem for a system of ODEs.
    
    This function numerically integrates a system of ordinary differential
    equations given an initial value::
    
        dy / dt = f(t, y)
        y(t0) = y0
    
    Here t is a one-dimensional independent variable (time), y(t) is an
    n-dimensional vector-valued function (state), and an n-dimensional
    vector-valued function f(t, y) determines the differential equations.
    The goal is to find y(t) approximately satisfying the differential
    equations, given an initial value y(t0)=y0.
    
    Some of the solvers support integration in the complex domain, but note that
    for stiff ODE solvers, the right-hand side must be complex-differentiable
    (satisfy Cauchy-Riemann equations [11]_). To solve a problem in the complex
    domain, pass y0 with a complex data type. Another option is always to
    rewrite your problem for real and imaginary parts separately.
    
    Parameters
    ----------
    fun : callable
        Right-hand side of the system. The calling signature is ``fun(t, y)``.
        Here ``t`` is a scalar, and there are two options for the ndarray ``y``:
        It can either have shape (n,); then ``fun`` must return array_like with
        shape (n,). Alternatively it can have shape (n, k); then ``fun``
        must return an array_like with shape (n, k), i.e. each column
        corresponds to a single column in ``y``. The choice between the two
        options is determined by `vectorized` argument (see below). The
        vectorized implementation allows a faster approximation of the Jacobian
        by finite differences (required for stiff solvers).
    t_span : 2-tuple of floats
        Interval of integration (t0, tf). The solver starts with t=t0 and
        integrates until it reaches t=tf.
    y0 : array_like, shape (n,)
        Initial state. For problems in the complex domain, pass `y0` with a
        complex data type (even if the initial guess is purely real).
    method : string or `OdeSolver`, optional
        Integration method to use:
    
            * 'RK45' (default): Explicit Runge-Kutta method of order 5(4) [1]_.
              The error is controlled assuming accuracy of the fourth-order
              method, but steps are taken using the fifth-order accurate formula
              (local extrapolation is done). A quartic interpolation polynomial
              is used for the dense output [2]_. Can be applied in the complex domain.
            * 'RK23': Explicit Runge-Kutta method of order 3(2) [3]_. The error
              is controlled assuming accuracy of the second-order method, but
              steps are taken using the third-order accurate formula (local
              extrapolation is done). A cubic Hermite polynomial is used for the
              dense output. Can be applied in the complex domain.
            * 'Radau': Implicit Runge-Kutta method of the Radau IIA family of
              order 5 [4]_. The error is controlled with a third-order accurate
              embedded formula. A cubic polynomial which satisfies the
              collocation conditions is used for the dense output.
            * 'BDF': Implicit multi-step variable-order (1 to 5) method based
              on a backward differentiation formula for the derivative
              approximation [5]_. The implementation follows the one described
              in [6]_. A quasi-constant step scheme is used and accuracy is
              enhanced using the NDF modification. Can be applied in the complex
              domain.
            * 'LSODA': Adams/BDF method with automatic stiffness detection and
              switching [7]_, [8]_. This is a wrapper of the Fortran solver
              from ODEPACK.
    
        You should use the 'RK45' or 'RK23' method for non-stiff problems and
        'Radau' or 'BDF' for stiff problems [9]_. If not sure, first try to run
        'RK45'. If needs unusually many iterations, diverges, or fails, your
        problem is likely to be stiff and you should use 'Radau' or 'BDF'.
        'LSODA' can also be a good universal choice, but it might be somewhat
        less convenient to work with as it wraps old Fortran code.
    
        You can also pass an arbitrary class derived from `OdeSolver` which
        implements the solver.
    dense_output : bool, optional
        Whether to compute a continuous solution. Default is False.
    t_eval : array_like or None, optional
        Times at which to store the computed solution, must be sorted and lie
        within `t_span`. If None (default), use points selected by the solver.
    events : callable, list of callables or None, optional
        Types of events to track. Each is defined by a continuous function of
        time and state that becomes zero value in case of an event. Each function
        must have the signature ``event(t, y)`` and return a float. The solver will
        find an accurate value of ``t`` at which ``event(t, y(t)) = 0`` using a
        root-finding algorithm. Additionally each ``event`` function might have
        the following attributes:
    
            * terminal: bool, whether to terminate integration if this
              event occurs. Implicitly False if not assigned.
            * direction: float, direction of a zero crossing. If `direction`
              is positive, `event` must go from negative to positive, and
              vice versa if `direction` is negative. If 0, then either direction
              will count. Implicitly 0 if not assigned.
    
        You can assign attributes like ``event.terminal = True`` to any
        function in Python. If None (default), events won't be tracked.
    vectorized : bool, optional
        Whether `fun` is implemented in a vectorized fashion. Default is False.
    options
        Options passed to a chosen solver. All options available for already
        implemented solvers are listed below.
    max_step : float, optional
        Maximum allowed step size. Default is np.inf, i.e. the step size is not
        bounded and determined solely by the solver.
    rtol, atol : float and array_like, optional
        Relative and absolute tolerances. The solver keeps the local error
        estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
        relative accuracy (number of correct digits). But if a component of `y`
        is approximately below `atol`, the error only needs to fall within
        the same `atol` threshold, and the number of correct digits is not
        guaranteed. If components of y have different scales, it might be
        beneficial to set different `atol` values for different components by
        passing array_like with shape (n,) for `atol`. Default values are
        1e-3 for `rtol` and 1e-6 for `atol`.
    jac : {None, array_like, sparse_matrix, callable}, optional
        Jacobian matrix of the right-hand side of the system with respect to
        y, required by the 'Radau', 'BDF' and 'LSODA' method. The Jacobian matrix
        has shape (n, n) and its element (i, j) is equal to ``d f_i / d y_j``.
        There are three ways to define the Jacobian:
    
            * If array_like or sparse_matrix, the Jacobian is assumed to
              be constant. Not supported by 'LSODA'.
            * If callable, the Jacobian is assumed to depend on both
              t and y; it will be called as ``jac(t, y)`` as necessary.
              For the 'Radau' and 'BDF' methods, the return value might be a
              sparse matrix.
            * If None (default), the Jacobian will be approximated by
              finite differences.
    
        It is generally recommended to provide the Jacobian rather than
        relying on a finite-difference approximation.
    jac_sparsity : {None, array_like, sparse matrix}, optional
        Defines a sparsity structure of the Jacobian matrix for a
        finite-difference approximation. Its shape must be (n, n). This argument
        is ignored if `jac` is not `None`. If the Jacobian has only few non-zero
        elements in *each* row, providing the sparsity structure will greatly
        speed up the computations [10]_. A zero entry means that a corresponding
        element in the Jacobian is always zero. If None (default), the Jacobian
        is assumed to be dense.
        Not supported by 'LSODA', see `lband` and `uband` instead.
    lband, uband : int or None
        Parameters defining the bandwidth of the Jacobian for the 'LSODA' method,
        i.e., ``jac[i, j] != 0 only for i - lband <= j <= i + uband``. Setting
        these requires your jac routine to return the Jacobian in the packed format:
        the returned array must have ``n`` columns and ``uband + lband + 1``
        rows in which Jacobian diagonals are written. Specifically
        ``jac_packed[uband + i - j , j] = jac[i, j]``. The same format is used
        in `scipy.linalg.solve_banded` (check for an illustration).
        These parameters can be also used with ``jac=None`` to reduce the
        number of Jacobian elements estimated by finite differences.
    min_step, first_step : float, optional
        The minimum allowed step size and the initial step size respectively
        for 'LSODA' method. By default `min_step` is zero and `first_step` is
        selected automatically.
    
    Returns
    -------
    Bunch object with the following fields defined:
    t : ndarray, shape (n_points,)
        Time points.
    y : ndarray, shape (n, n_points)
        Values of the solution at `t`.
    sol : `OdeSolution` or None
        Found solution as `OdeSolution` instance; None if `dense_output` was
        set to False.
    t_events : list of ndarray or None
        Contains for each event type a list of arrays at which an event of
        that type event was detected. None if `events` was None.
    nfev : int
        Number of evaluations of the right-hand side.
    njev : int
        Number of evaluations of the Jacobian.
    nlu : int
        Number of LU decompositions.
    status : int
        Reason for algorithm termination:
    
            * -1: Integration step failed.
            *  0: The solver successfully reached the end of `tspan`.
            *  1: A termination event occurred.
    
    message : string
        Human-readable description of the termination reason.
    success : bool
        True if the solver reached the interval end or a termination event
        occurred (``status >= 0``).
    
    References
    ----------
    .. [1] J. R. Dormand, P. J. Prince, ""A family of embedded Runge-Kutta
           formulae"", Journal of Computational and Applied Mathematics, Vol. 6,
           No. 1, pp. 19-26, 1980.
    .. [2] L. W. Shampine, ""Some Practical Runge-Kutta Formulas"", Mathematics
           of Computation,, Vol. 46, No. 173, pp. 135-150, 1986.
    .. [3] P. Bogacki, L.F. Shampine, ""A 3(2) Pair of Runge-Kutta Formulas"",
           Appl. Math. Lett. Vol. 2, No. 4. pp. 321-325, 1989.
    .. [4] E. Hairer, G. Wanner, ""Solving Ordinary Differential Equations II:
           Stiff and Differential-Algebraic Problems"", Sec. IV.8.
    .. [5] `Backward Differentiation Formula
            <https://en.wikipedia.org/wiki/Backward_differentiation_formula>`_
            on Wikipedia.
    .. [6] L. F. Shampine, M. W. Reichelt, ""THE MATLAB ODE SUITE"", SIAM J. SCI.
           COMPUTE., Vol. 18, No. 1, pp. 1-22, January 1997.
    .. [7] A. C. Hindmarsh, ""ODEPACK, A Systematized Collection of ODE
           Solvers,"" IMACS Transactions on Scientific Computation, Vol 1.,
           pp. 55-64, 1983.
    .. [8] L. Petzold, ""Automatic selection of methods for solving stiff and
           nonstiff systems of ordinary differential equations"", SIAM Journal
           on Scientific and Statistical Computing, Vol. 4, No. 1, pp. 136-148,
           1983.
    .. [9] `Stiff equation <https://en.wikipedia.org/wiki/Stiff_equation>`_ on
           Wikipedia.
    .. [10] A. Curtis, M. J. D. Powell, and J. Reid, ""On the estimation of
            sparse Jacobian matrices"", Journal of the Institute of Mathematics
            and its Applications, 13, pp. 117-120, 1974.
    .. [11] `Cauchy-Riemann equations
             <https://en.wikipedia.org/wiki/Cauchy-Riemann_equations>`_ on
             Wikipedia.
    
    Examples
    --------
    Basic exponential decay showing automatically chosen time points.
    
    >>> from scipy.integrate import solve_ivp
    >>> def exponential_decay(t, y): return -0.5 * y
    >>> sol = solve_ivp(exponential_decay, [0, 10], [2, 4, 8])
    >>> print(sol.t)
    [  0.           0.11487653   1.26364188   3.06061781   4.85759374
       6.65456967   8.4515456   10.        ]
    >>> print(sol.y)
    [[2.         1.88836035 1.06327177 0.43319312 0.17648948 0.0719045
      0.02929499 0.01350938]
     [4.         3.7767207  2.12654355 0.86638624 0.35297895 0.143809
      0.05858998 0.02701876]
     [8.         7.5534414  4.25308709 1.73277247 0.7059579  0.287618
      0.11717996 0.05403753]]
    
    Specifying points where the solution is desired.
    
    >>> sol = solve_ivp(exponential_decay, [0, 10], [2, 4, 8],
    ...                 t_eval=[0, 1, 2, 4, 10])
    >>> print(sol.t)
    [ 0  1  2  4 10]
    >>> print(sol.y)
    [[2.         1.21305369 0.73534021 0.27066736 0.01350938]
     [4.         2.42610739 1.47068043 0.54133472 0.02701876]
     [8.         4.85221478 2.94136085 1.08266944 0.05403753]]
    
    Cannon fired upward with terminal event upon impact. The ``terminal`` and
    ``direction`` fields of an event are applied by monkey patching a function.
    Here ``y[0]`` is position and ``y[1]`` is velocity. The projectile starts at
    position 0 with velocity +10. Note that the integration never reaches t=100
    because the event is terminal.
    
    >>> def upward_cannon(t, y): return [y[1], -0.5]
    >>> def hit_ground(t, y): return y[1]
    >>> hit_ground.terminal = True
    >>> hit_ground.direction = -1
    >>> sol = solve_ivp(upward_cannon, [0, 100], [0, 10], events=hit_ground)
    >>> print(sol.t_events)
    [array([ 20.])]
    >>> print(sol.t)
    [0.00000000e+00 9.99900010e-05 1.09989001e-03 1.10988901e-02
     1.11088891e-01 1.11098890e+00 1.11099890e+01 2.00000000e+01]
",function,"('fun', 't_span', 'y0', 'method', 't_eval', 'dense_output', 'events', 'vectorized')","(nan, nan, nan, 'RK45', None, False, None, False)","(nan, nan, nan, 'str', 'NoneType', 'bool', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(fun, t_span, y0, method='RK45', t_eval=None, dense_output=False, events=None, vectorized=False, **options)"",)"
scipy,1.1.0,scipy.integrate._ode.IntegratorBase,integrate._ode,IntegratorBase,"Python Library Documentation: class IntegratorBase in module scipy.integrate._ode

class IntegratorBase(builtins.object)
 |  Methods defined here:
 |  
 |  acquire_new_handle(self)
 |  
 |  check_handle(self)
 |  
 |  reset(self, n, has_jac)
 |      Prepare integrator for call: allocate memory, set flags, etc.
 |      n - number of equations.
 |      has_jac - if user has supplied function for evaluating Jacobian.
 |  
 |  run(self, f, jac, y0, t0, t1, f_params, jac_params)
 |      Integrate from t=t0 to t=t1 using y0 as an initial condition.
 |      Return 2-tuple (y1,t1) where y1 is the result and t=t1
 |      defines the stoppage coordinate of the result.
 |  
 |  run_relax(self, f, jac, y0, t0, t1, f_params, jac_params)
 |      Integrate from t=t0 to t>=t1 and return (y1,t).
 |  
 |  step(self, f, jac, y0, t0, t1, f_params, jac_params)
 |      Make one integration step and return (y1,t1).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  integrator_classes = [<class 'scipy.integrate._ode.vode'>, <class 'sci...
 |  
 |  istate = None
 |  
 |  runner = None
 |  
 |  scalar = <class 'float'>
 |      float(x) -> floating point number
 |      
 |      Convert a string or number to a floating point number, if possible.
 |  
 |  success = None
 |  
 |  supports_run_relax = None
 |  
 |  supports_solout = False
 |  
 |  supports_step = None
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.integrate._ode.IntegratorBase,integrate._ode,IntegratorBase,"Python Library Documentation: class IntegratorBase in module scipy.integrate._ode

class IntegratorBase(builtins.object)
 |  Methods defined here:
 |  
 |  acquire_new_handle(self)
 |  
 |  check_handle(self)
 |  
 |  reset(self, n, has_jac)
 |      Prepare integrator for call: allocate memory, set flags, etc.
 |      n - number of equations.
 |      has_jac - if user has supplied function for evaluating Jacobian.
 |  
 |  run(self, f, jac, y0, t0, t1, f_params, jac_params)
 |      Integrate from t=t0 to t=t1 using y0 as an initial condition.
 |      Return 2-tuple (y1,t1) where y1 is the result and t=t1
 |      defines the stoppage coordinate of the result.
 |  
 |  run_relax(self, f, jac, y0, t0, t1, f_params, jac_params)
 |      Integrate from t=t0 to t>=t1 and return (y1,t).
 |  
 |  step(self, f, jac, y0, t0, t1, f_params, jac_params)
 |      Make one integration step and return (y1,t1).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  integrator_classes = [<class 'scipy.integrate._ode.vode'>, <class 'sci...
 |  
 |  istate = None
 |  
 |  runner = None
 |  
 |  scalar = <class 'float'>
 |      float(x) -> floating point number
 |      
 |      Convert a string or number to a floating point number, if possible.
 |  
 |  success = None
 |  
 |  supports_run_relax = None
 |  
 |  supports_solout = False
 |  
 |  supports_step = None
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.integrate._ode.IntegratorConcurrencyError,integrate._ode,IntegratorConcurrencyError,"Python Library Documentation: class IntegratorConcurrencyError in module scipy.integrate._ode

class IntegratorConcurrencyError(builtins.RuntimeError)
 |  Failure due to concurrent usage of an integrator that can be used
 |  only for a single problem at a time.
 |  
 |  Method resolution order:
 |      IntegratorConcurrencyError
 |      builtins.RuntimeError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, name)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.RuntimeError:
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, name)',)",scipy,1.1.0,scipy.integrate._ode.IntegratorConcurrencyError,integrate._ode,IntegratorConcurrencyError,"Python Library Documentation: class IntegratorConcurrencyError in module scipy.integrate._ode

class IntegratorConcurrencyError(builtins.RuntimeError)
 |  Failure due to concurrent usage of an integrator that can be used
 |  only for a single problem at a time.
 |  
 |  Method resolution order:
 |      IntegratorConcurrencyError
 |      builtins.RuntimeError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, name)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.RuntimeError:
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self', 'name')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(self, name)',)"
scipy,1.1.0,scipy.integrate._ode._transform_banded_jac,integrate._ode,_transform_banded_jac,"Python Library Documentation: function _transform_banded_jac in module scipy.integrate._ode

_transform_banded_jac(bjac)
    Convert a real matrix of the form (for example)
    
        [0 0 A B]        [0 0 0 B]
        [0 0 C D]        [0 0 A D]
        [E F G H]   to   [0 F C H]
        [I J K L]        [E J G L]
                         [I 0 K 0]
    
    That is, every other column is shifted up one.
",function,"('(bjac)',)",scipy,1.1.0,scipy.integrate._ode._transform_banded_jac,integrate._ode,_transform_banded_jac,"Python Library Documentation: function _transform_banded_jac in module scipy.integrate._ode

_transform_banded_jac(bjac)
    Convert a real matrix of the form (for example)
    
        [0 0 A B]        [0 0 0 B]
        [0 0 C D]        [0 0 A D]
        [E F G H]   to   [0 F C H]
        [I J K L]        [E J G L]
                         [I 0 K 0]
    
    That is, every other column is shifted up one.
",function,"('bjac',)","(nan,)","(nan,)","('arg_info',)","('(bjac)',)"
scipy,1.1.0,scipy.integrate._ode._vode_banded_jac_wrapper,integrate._ode,_vode_banded_jac_wrapper,"Python Library Documentation: function _vode_banded_jac_wrapper in module scipy.integrate._ode

_vode_banded_jac_wrapper(jacfunc, ml, jac_params)
    Wrap a banded Jacobian function with a function that pads
    the Jacobian with `ml` rows of zeros.
",function,"('(jacfunc, ml, jac_params)',)",scipy,1.1.0,scipy.integrate._ode._vode_banded_jac_wrapper,integrate._ode,_vode_banded_jac_wrapper,"Python Library Documentation: function _vode_banded_jac_wrapper in module scipy.integrate._ode

_vode_banded_jac_wrapper(jacfunc, ml, jac_params)
    Wrap a banded Jacobian function with a function that pads
    the Jacobian with `ml` rows of zeros.
",function,"('jacfunc', 'ml', 'jac_params')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(jacfunc, ml, jac_params)',)"
scipy,1.1.0,scipy.integrate._ode.asarray,integrate._ode,asarray,"Python Library Documentation: function asarray in module numpy.core.numeric

asarray(a, dtype=None, order=None)
    Convert the input to an array.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
        Whether to use row-major (C-style) or
        column-major (Fortran-style) memory representation.
        Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray with matching dtype and order.  If `a` is a
        subclass of ndarray, a base class ndarray is returned.
    
    See Also
    --------
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    asarray_chkfinite : Similar function which checks input for NaNs and Infs.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array:
    
    >>> a = [1, 2]
    >>> np.asarray(a)
    array([1, 2])
    
    Existing arrays are not copied:
    
    >>> a = np.array([1, 2])
    >>> np.asarray(a) is a
    True
    
    If `dtype` is set, array is copied only if dtype does not match:
    
    >>> a = np.array([1, 2], dtype=np.float32)
    >>> np.asarray(a, dtype=np.float32) is a
    True
    >>> np.asarray(a, dtype=np.float64) is a
    False
    
    Contrary to `asanyarray`, ndarray subclasses are not passed through:
    
    >>> issubclass(np.matrix, np.ndarray)
    True
    >>> a = np.matrix([[1, 2]])
    >>> np.asarray(a) is a
    False
    >>> np.asanyarray(a) is a
    True
",function,"('(a, dtype=None, order=None)',)",scipy,1.1.0,scipy.integrate._ode.asarray,integrate._ode,asarray,"Python Library Documentation: function asarray in module numpy.core.numeric

asarray(a, dtype=None, order=None)
    Convert the input to an array.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
        Whether to use row-major (C-style) or
        column-major (Fortran-style) memory representation.
        Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray with matching dtype and order.  If `a` is a
        subclass of ndarray, a base class ndarray is returned.
    
    See Also
    --------
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    asarray_chkfinite : Similar function which checks input for NaNs and Infs.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array:
    
    >>> a = [1, 2]
    >>> np.asarray(a)
    array([1, 2])
    
    Existing arrays are not copied:
    
    >>> a = np.array([1, 2])
    >>> np.asarray(a) is a
    True
    
    If `dtype` is set, array is copied only if dtype does not match:
    
    >>> a = np.array([1, 2], dtype=np.float32)
    >>> np.asarray(a, dtype=np.float32) is a
    True
    >>> np.asarray(a, dtype=np.float64) is a
    False
    
    Contrary to `asanyarray`, ndarray subclasses are not passed through:
    
    >>> issubclass(np.matrix, np.ndarray)
    True
    >>> a = np.matrix([[1, 2]])
    >>> np.asarray(a) is a
    False
    >>> np.asanyarray(a) is a
    True
",function,"('a', 'dtype', 'order')","(nan, None, None)","(nan, 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(a, dtype=None, order=None)',)"
scipy,1.1.0,scipy.integrate._ode.complex_ode,integrate._ode,complex_ode,"Python Library Documentation: class complex_ode in module scipy.integrate._ode

class complex_ode(ode)
 |  A wrapper of ode for complex systems.
 |  
 |  This functions similarly as `ode`, but re-maps a complex-valued
 |  equation system to a real-valued one before using the integrators.
 |  
 |  Parameters
 |  ----------
 |  f : callable ``f(t, y, *f_args)``
 |      Rhs of the equation. t is a scalar, ``y.shape == (n,)``.
 |      ``f_args`` is set by calling ``set_f_params(*args)``.
 |  jac : callable ``jac(t, y, *jac_args)``
 |      Jacobian of the rhs, ``jac[i,j] = d f[i] / d y[j]``.
 |      ``jac_args`` is set by calling ``set_f_params(*args)``.
 |  
 |  Attributes
 |  ----------
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current variable values.
 |  
 |  Examples
 |  --------
 |  For usage examples, see `ode`.
 |  
 |  Method resolution order:
 |      complex_ode
 |      ode
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, f, jac=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  integrate(self, t, step=False, relax=False)
 |      Find y=y(t), set y as an initial condition, and return y.
 |      
 |      Parameters
 |      ----------
 |      t : float
 |          The endpoint of the integration step.
 |      step : bool
 |          If True, and if the integrator supports the step method,
 |          then perform a single integration step and return.
 |          This parameter is provided in order to expose internals of
 |          the implementation, and should not be changed from its default
 |          value in most cases.
 |      relax : bool
 |          If True and if the integrator supports the run_relax method,
 |          then integrate until t_1 >= t and return. ``relax`` is not
 |          referenced if ``step=True``.
 |          This parameter is provided in order to expose internals of
 |          the implementation, and should not be changed from its default
 |          value in most cases.
 |      
 |      Returns
 |      -------
 |      y : float
 |          The integrated value at t
 |  
 |  set_initial_value(self, y, t=0.0)
 |      Set initial conditions y(t) = y.
 |  
 |  set_integrator(self, name, **integrator_params)
 |      Set integrator by name.
 |      
 |      Parameters
 |      ----------
 |      name : str
 |          Name of the integrator
 |      integrator_params
 |          Additional parameters for the integrator.
 |  
 |  set_solout(self, solout)
 |      Set callable to be called at every successful integration step.
 |      
 |      Parameters
 |      ----------
 |      solout : callable
 |          ``solout(t, y)`` is called at each internal integrator step,
 |          t is a scalar providing the current independent position
 |          y is the current soloution ``y.shape == (n,)``
 |          solout should return -1 to stop integration
 |          otherwise it should return None or 0
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  y
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from ode:
 |  
 |  get_return_code(self)
 |      Extracts the return code for the integration to enable better control
 |      if the integration fails.
 |      
 |      In general, a return code > 0 implies success while a return code < 0
 |      implies failure.
 |      
 |      Notes
 |      -----
 |      This section describes possible return codes and their meaning, for available
 |      integrators that can be selected by `set_integrator` method.
 |      
 |      ""vode""
 |      
 |      ===========  =======
 |      Return Code  Message
 |      ===========  =======
 |      2            Integration successful.
 |      -1           Excess work done on this call. (Perhaps wrong MF.)
 |      -2           Excess accuracy requested. (Tolerances too small.)
 |      -3           Illegal input detected. (See printed message.)
 |      -4           Repeated error test failures. (Check all input.)
 |      -5           Repeated convergence failures. (Perhaps bad Jacobian
 |                   supplied or wrong choice of MF or tolerances.)
 |      -6           Error weight became zero during problem. (Solution
 |                   component i vanished, and ATOL or ATOL(i) = 0.)
 |      ===========  =======
 |      
 |      ""zvode""
 |      
 |      ===========  =======
 |      Return Code  Message
 |      ===========  =======
 |      2            Integration successful.
 |      -1           Excess work done on this call. (Perhaps wrong MF.)
 |      -2           Excess accuracy requested. (Tolerances too small.)
 |      -3           Illegal input detected. (See printed message.)
 |      -4           Repeated error test failures. (Check all input.)
 |      -5           Repeated convergence failures. (Perhaps bad Jacobian
 |                   supplied or wrong choice of MF or tolerances.)
 |      -6           Error weight became zero during problem. (Solution
 |                   component i vanished, and ATOL or ATOL(i) = 0.)
 |      ===========  =======
 |      
 |      ""dopri5""
 |      
 |      ===========  =======
 |      Return Code  Message
 |      ===========  =======
 |      1            Integration successful.
 |      2            Integration successful (interrupted by solout).
 |      -1           Input is not consistent.
 |      -2           Larger nsteps is needed.
 |      -3           Step size becomes too small.
 |      -4           Problem is probably stiff (interrupted).
 |      ===========  =======
 |      
 |      ""dop853""
 |      
 |      ===========  =======
 |      Return Code  Message
 |      ===========  =======
 |      1            Integration successful.
 |      2            Integration successful (interrupted by solout).
 |      -1           Input is not consistent.
 |      -2           Larger nsteps is needed.
 |      -3           Step size becomes too small.
 |      -4           Problem is probably stiff (interrupted).
 |      ===========  =======
 |      
 |      ""lsoda""
 |      
 |      ===========  =======
 |      Return Code  Message
 |      ===========  =======
 |      2            Integration successful.
 |      -1           Excess work done on this call (perhaps wrong Dfun type).
 |      -2           Excess accuracy requested (tolerances too small).
 |      -3           Illegal input detected (internal error).
 |      -4           Repeated error test failures (internal error).
 |      -5           Repeated convergence failures (perhaps bad Jacobian or tolerances).
 |      -6           Error weight became zero during problem.
 |      -7           Internal workspace insufficient to finish (internal error).
 |      ===========  =======
 |  
 |  set_f_params(self, *args)
 |      Set extra parameters for user-supplied function f.
 |  
 |  set_jac_params(self, *args)
 |      Set extra parameters for user-supplied function jac.
 |  
 |  successful(self)
 |      Check if integration was successful.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from ode:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, f, jac=None)',)",scipy,1.1.0,scipy.integrate._ode.complex_ode,integrate._ode,complex_ode,"Python Library Documentation: class complex_ode in module scipy.integrate._ode

class complex_ode(ode)
 |  A wrapper of ode for complex systems.
 |  
 |  This functions similarly as `ode`, but re-maps a complex-valued
 |  equation system to a real-valued one before using the integrators.
 |  
 |  Parameters
 |  ----------
 |  f : callable ``f(t, y, *f_args)``
 |      Rhs of the equation. t is a scalar, ``y.shape == (n,)``.
 |      ``f_args`` is set by calling ``set_f_params(*args)``.
 |  jac : callable ``jac(t, y, *jac_args)``
 |      Jacobian of the rhs, ``jac[i,j] = d f[i] / d y[j]``.
 |      ``jac_args`` is set by calling ``set_f_params(*args)``.
 |  
 |  Attributes
 |  ----------
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current variable values.
 |  
 |  Examples
 |  --------
 |  For usage examples, see `ode`.
 |  
 |  Method resolution order:
 |      complex_ode
 |      ode
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, f, jac=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  integrate(self, t, step=False, relax=False)
 |      Find y=y(t), set y as an initial condition, and return y.
 |      
 |      Parameters
 |      ----------
 |      t : float
 |          The endpoint of the integration step.
 |      step : bool
 |          If True, and if the integrator supports the step method,
 |          then perform a single integration step and return.
 |          This parameter is provided in order to expose internals of
 |          the implementation, and should not be changed from its default
 |          value in most cases.
 |      relax : bool
 |          If True and if the integrator supports the run_relax method,
 |          then integrate until t_1 >= t and return. ``relax`` is not
 |          referenced if ``step=True``.
 |          This parameter is provided in order to expose internals of
 |          the implementation, and should not be changed from its default
 |          value in most cases.
 |      
 |      Returns
 |      -------
 |      y : float
 |          The integrated value at t
 |  
 |  set_initial_value(self, y, t=0.0)
 |      Set initial conditions y(t) = y.
 |  
 |  set_integrator(self, name, **integrator_params)
 |      Set integrator by name.
 |      
 |      Parameters
 |      ----------
 |      name : str
 |          Name of the integrator
 |      integrator_params
 |          Additional parameters for the integrator.
 |  
 |  set_solout(self, solout)
 |      Set callable to be called at every successful integration step.
 |      
 |      Parameters
 |      ----------
 |      solout : callable
 |          ``solout(t, y)`` is called at each internal integrator step,
 |          t is a scalar providing the current independent position
 |          y is the current soloution ``y.shape == (n,)``
 |          solout should return -1 to stop integration
 |          otherwise it should return None or 0
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  y
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from ode:
 |  
 |  get_return_code(self)
 |      Extracts the return code for the integration to enable better control
 |      if the integration fails.
 |      
 |      In general, a return code > 0 implies success while a return code < 0
 |      implies failure.
 |      
 |      Notes
 |      -----
 |      This section describes possible return codes and their meaning, for available
 |      integrators that can be selected by `set_integrator` method.
 |      
 |      ""vode""
 |      
 |      ===========  =======
 |      Return Code  Message
 |      ===========  =======
 |      2            Integration successful.
 |      -1           Excess work done on this call. (Perhaps wrong MF.)
 |      -2           Excess accuracy requested. (Tolerances too small.)
 |      -3           Illegal input detected. (See printed message.)
 |      -4           Repeated error test failures. (Check all input.)
 |      -5           Repeated convergence failures. (Perhaps bad Jacobian
 |                   supplied or wrong choice of MF or tolerances.)
 |      -6           Error weight became zero during problem. (Solution
 |                   component i vanished, and ATOL or ATOL(i) = 0.)
 |      ===========  =======
 |      
 |      ""zvode""
 |      
 |      ===========  =======
 |      Return Code  Message
 |      ===========  =======
 |      2            Integration successful.
 |      -1           Excess work done on this call. (Perhaps wrong MF.)
 |      -2           Excess accuracy requested. (Tolerances too small.)
 |      -3           Illegal input detected. (See printed message.)
 |      -4           Repeated error test failures. (Check all input.)
 |      -5           Repeated convergence failures. (Perhaps bad Jacobian
 |                   supplied or wrong choice of MF or tolerances.)
 |      -6           Error weight became zero during problem. (Solution
 |                   component i vanished, and ATOL or ATOL(i) = 0.)
 |      ===========  =======
 |      
 |      ""dopri5""
 |      
 |      ===========  =======
 |      Return Code  Message
 |      ===========  =======
 |      1            Integration successful.
 |      2            Integration successful (interrupted by solout).
 |      -1           Input is not consistent.
 |      -2           Larger nsteps is needed.
 |      -3           Step size becomes too small.
 |      -4           Problem is probably stiff (interrupted).
 |      ===========  =======
 |      
 |      ""dop853""
 |      
 |      ===========  =======
 |      Return Code  Message
 |      ===========  =======
 |      1            Integration successful.
 |      2            Integration successful (interrupted by solout).
 |      -1           Input is not consistent.
 |      -2           Larger nsteps is needed.
 |      -3           Step size becomes too small.
 |      -4           Problem is probably stiff (interrupted).
 |      ===========  =======
 |      
 |      ""lsoda""
 |      
 |      ===========  =======
 |      Return Code  Message
 |      ===========  =======
 |      2            Integration successful.
 |      -1           Excess work done on this call (perhaps wrong Dfun type).
 |      -2           Excess accuracy requested (tolerances too small).
 |      -3           Illegal input detected (internal error).
 |      -4           Repeated error test failures (internal error).
 |      -5           Repeated convergence failures (perhaps bad Jacobian or tolerances).
 |      -6           Error weight became zero during problem.
 |      -7           Internal workspace insufficient to finish (internal error).
 |      ===========  =======
 |  
 |  set_f_params(self, *args)
 |      Set extra parameters for user-supplied function f.
 |  
 |  set_jac_params(self, *args)
 |      Set extra parameters for user-supplied function jac.
 |  
 |  successful(self)
 |      Check if integration was successful.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from ode:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'f', 'jac')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(self, f, jac=None)',)"
scipy,1.1.0,scipy.integrate._ode.dop853,integrate._ode,dop853,"Python Library Documentation: class dop853 in module scipy.integrate._ode

class dop853(dopri5)
 |  Method resolution order:
 |      dop853
 |      dopri5
 |      IntegratorBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, rtol=1e-06, atol=1e-12, nsteps=500, max_step=0.0, first_step=0.0, safety=0.9, ifactor=6.0, dfactor=0.3, beta=0.0, method=None, verbosity=-1)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  reset(self, n, has_jac)
 |      Prepare integrator for call: allocate memory, set flags, etc.
 |      n - number of equations.
 |      has_jac - if user has supplied function for evaluating Jacobian.
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  name = 'dop853'
 |  
 |  runner = <fortran object>
 |      x,y,iwork,idid = dop853(fcn,x,y,xend,rtol,atol,solout,iout,work,iwork,[fcn_extra_args,overwrite_y,solout_extra_args])
 |      
 |      Wrapper for ``dop853``.
 |      
 |      Parameters
 |      ----------
 |      fcn : call-back function
 |      x : input float
 |      y : input rank-1 array('d') with bounds (n)
 |      xend : input float
 |      rtol : input rank-1 array('d') with bounds (*)
 |      atol : input rank-1 array('d') with bounds (*)
 |      solout : call-back function
 |      iout : input int
 |      work : input rank-1 array('d') with bounds (*)
 |      iwork : input rank-1 array('i') with bounds (*)
 |      
 |      Other Parameters
 |      ----------------
 |      fcn_extra_args : input tuple, optional
 |          Default: ()
 |      overwrite_y : input int, optional
 |          Default: 0
 |      solout_extra_args : input tuple, optional
 |          Default: ()
 |      
 |      Returns
 |      -------
 |      x : float
 |      y : rank-1 array('d') with bounds (n)
 |      iwork : rank-1 array('i') with bounds (*)
 |      idid : int
 |      
 |      Notes
 |      -----
 |      Call-back functions::
 |      
 |        def fcn(x,y): return f
 |        Required arguments:
 |          x : input float
 |          y : input rank-1 array('d') with bounds (n)
 |        Return objects:
 |          f : rank-1 array('d') with bounds (n)
 |        def solout(nr,xold,x,y,con,icomp,[nd]): return irtn
 |        Required arguments:
 |          nr : input int
 |          xold : input float
 |          x : input float
 |          y : input rank-1 array('d') with bounds (n)
 |          con : input rank-1 array('d') with bounds (5 * nd)
 |          icomp : input rank-1 array('i') with bounds (nd)
 |        Optional arguments:
 |          nd : input int, optional
 |          Default: (len(con))/(5)
 |        Return objects:
 |          irtn : int
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from dopri5:
 |  
 |  run(self, f, jac, y0, t0, t1, f_params, jac_params)
 |      Integrate from t=t0 to t=t1 using y0 as an initial condition.
 |      Return 2-tuple (y1,t1) where y1 is the result and t=t1
 |      defines the stoppage coordinate of the result.
 |  
 |  set_solout(self, solout, complex=False)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from dopri5:
 |  
 |  messages = {-4: 'problem is probably stiff (interrupted)', -3: 'step s...
 |  
 |  supports_solout = True
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from IntegratorBase:
 |  
 |  acquire_new_handle(self)
 |  
 |  check_handle(self)
 |  
 |  run_relax(self, f, jac, y0, t0, t1, f_params, jac_params)
 |      Integrate from t=t0 to t>=t1 and return (y1,t).
 |  
 |  step(self, f, jac, y0, t0, t1, f_params, jac_params)
 |      Make one integration step and return (y1,t1).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IntegratorBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from IntegratorBase:
 |  
 |  integrator_classes = [<class 'scipy.integrate._ode.vode'>, <class 'sci...
 |  
 |  istate = None
 |  
 |  scalar = <class 'float'>
 |      float(x) -> floating point number
 |      
 |      Convert a string or number to a floating point number, if possible.
 |  
 |  success = None
 |  
 |  supports_run_relax = None
 |  
 |  supports_step = None
",class,"('(self, rtol=1e-06, atol=1e-12, nsteps=500, max_step=0.0, first_step=0.0, safety=0.9, ifactor=6.0, dfactor=0.3, beta=0.0, method=None, verbosity=-1)',)",scipy,1.1.0,scipy.integrate._ode.dop853,integrate._ode,dop853,"Python Library Documentation: class dop853 in module scipy.integrate._ode

class dop853(dopri5)
 |  Method resolution order:
 |      dop853
 |      dopri5
 |      IntegratorBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, rtol=1e-06, atol=1e-12, nsteps=500, max_step=0.0, first_step=0.0, safety=0.9, ifactor=6.0, dfactor=0.3, beta=0.0, method=None, verbosity=-1)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  reset(self, n, has_jac)
 |      Prepare integrator for call: allocate memory, set flags, etc.
 |      n - number of equations.
 |      has_jac - if user has supplied function for evaluating Jacobian.
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  name = 'dop853'
 |  
 |  runner = <fortran object>
 |      x,y,iwork,idid = dop853(fcn,x,y,xend,rtol,atol,solout,iout,work,iwork,[fcn_extra_args,overwrite_y,solout_extra_args])
 |      
 |      Wrapper for ``dop853``.
 |      
 |      Parameters
 |      ----------
 |      fcn : call-back function
 |      x : input float
 |      y : input rank-1 array('d') with bounds (n)
 |      xend : input float
 |      rtol : input rank-1 array('d') with bounds (*)
 |      atol : input rank-1 array('d') with bounds (*)
 |      solout : call-back function
 |      iout : input int
 |      work : input rank-1 array('d') with bounds (*)
 |      iwork : input rank-1 array('i') with bounds (*)
 |      
 |      Other Parameters
 |      ----------------
 |      fcn_extra_args : input tuple, optional
 |          Default: ()
 |      overwrite_y : input int, optional
 |          Default: 0
 |      solout_extra_args : input tuple, optional
 |          Default: ()
 |      
 |      Returns
 |      -------
 |      x : float
 |      y : rank-1 array('d') with bounds (n)
 |      iwork : rank-1 array('i') with bounds (*)
 |      idid : int
 |      
 |      Notes
 |      -----
 |      Call-back functions::
 |      
 |        def fcn(x,y): return f
 |        Required arguments:
 |          x : input float
 |          y : input rank-1 array('d') with bounds (n)
 |        Return objects:
 |          f : rank-1 array('d') with bounds (n)
 |        def solout(nr,xold,x,y,con,icomp,[nd]): return irtn
 |        Required arguments:
 |          nr : input int
 |          xold : input float
 |          x : input float
 |          y : input rank-1 array('d') with bounds (n)
 |          con : input rank-1 array('d') with bounds (5 * nd)
 |          icomp : input rank-1 array('i') with bounds (nd)
 |        Optional arguments:
 |          nd : input int, optional
 |          Default: (len(con))/(5)
 |        Return objects:
 |          irtn : int
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from dopri5:
 |  
 |  run(self, f, jac, y0, t0, t1, f_params, jac_params)
 |      Integrate from t=t0 to t=t1 using y0 as an initial condition.
 |      Return 2-tuple (y1,t1) where y1 is the result and t=t1
 |      defines the stoppage coordinate of the result.
 |  
 |  set_solout(self, solout, complex=False)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from dopri5:
 |  
 |  messages = {-4: 'problem is probably stiff (interrupted)', -3: 'step s...
 |  
 |  supports_solout = True
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from IntegratorBase:
 |  
 |  acquire_new_handle(self)
 |  
 |  check_handle(self)
 |  
 |  run_relax(self, f, jac, y0, t0, t1, f_params, jac_params)
 |      Integrate from t=t0 to t>=t1 and return (y1,t).
 |  
 |  step(self, f, jac, y0, t0, t1, f_params, jac_params)
 |      Make one integration step and return (y1,t1).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IntegratorBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from IntegratorBase:
 |  
 |  integrator_classes = [<class 'scipy.integrate._ode.vode'>, <class 'sci...
 |  
 |  istate = None
 |  
 |  scalar = <class 'float'>
 |      float(x) -> floating point number
 |      
 |      Convert a string or number to a floating point number, if possible.
 |  
 |  success = None
 |  
 |  supports_run_relax = None
 |  
 |  supports_step = None
",class,"('self', 'rtol', 'atol', 'nsteps', 'max_step', 'first_step', 'safety', 'ifactor', 'dfactor', 'beta', 'method', 'verbosity')","(nan, 1e-06, 1e-12, 500, 0.0, 0.0, 0.9, 6.0, 0.3, 0.0, None, -1)","(nan, 'float', 'float', 'int', 'float', 'float', 'float', 'float', 'float', 'float', 'NoneType', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, rtol=1e-06, atol=1e-12, nsteps=500, max_step=0.0, first_step=0.0, safety=0.9, ifactor=6.0, dfactor=0.3, beta=0.0, method=None, verbosity=-1)',)"
scipy,1.1.0,scipy.integrate._ode.dopri5,integrate._ode,dopri5,"Python Library Documentation: class dopri5 in module scipy.integrate._ode

class dopri5(IntegratorBase)
 |  Method resolution order:
 |      dopri5
 |      IntegratorBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, rtol=1e-06, atol=1e-12, nsteps=500, max_step=0.0, first_step=0.0, safety=0.9, ifactor=10.0, dfactor=0.2, beta=0.0, method=None, verbosity=-1)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  reset(self, n, has_jac)
 |      Prepare integrator for call: allocate memory, set flags, etc.
 |      n - number of equations.
 |      has_jac - if user has supplied function for evaluating Jacobian.
 |  
 |  run(self, f, jac, y0, t0, t1, f_params, jac_params)
 |      Integrate from t=t0 to t=t1 using y0 as an initial condition.
 |      Return 2-tuple (y1,t1) where y1 is the result and t=t1
 |      defines the stoppage coordinate of the result.
 |  
 |  set_solout(self, solout, complex=False)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  messages = {-4: 'problem is probably stiff (interrupted)', -3: 'step s...
 |  
 |  name = 'dopri5'
 |  
 |  runner = <fortran object>
 |      x,y,iwork,idid = dopri5(fcn,x,y,xend,rtol,atol,solout,iout,work,iwork,[fcn_extra_args,overwrite_y,solout_extra_args])
 |      
 |      Wrapper for ``dopri5``.
 |      
 |      Parameters
 |      ----------
 |      fcn : call-back function
 |      x : input float
 |      y : input rank-1 array('d') with bounds (n)
 |      xend : input float
 |      rtol : input rank-1 array('d') with bounds (*)
 |      atol : input rank-1 array('d') with bounds (*)
 |      solout : call-back function
 |      iout : input int
 |      work : input rank-1 array('d') with bounds (*)
 |      iwork : input rank-1 array('i') with bounds (*)
 |      
 |      Other Parameters
 |      ----------------
 |      fcn_extra_args : input tuple, optional
 |          Default: ()
 |      overwrite_y : input int, optional
 |          Default: 0
 |      solout_extra_args : input tuple, optional
 |          Default: ()
 |      
 |      Returns
 |      -------
 |      x : float
 |      y : rank-1 array('d') with bounds (n)
 |      iwork : rank-1 array('i') with bounds (*)
 |      idid : int
 |      
 |      Notes
 |      -----
 |      Call-back functions::
 |      
 |        def fcn(x,y): return f
 |        Required arguments:
 |          x : input float
 |          y : input rank-1 array('d') with bounds (n)
 |        Return objects:
 |          f : rank-1 array('d') with bounds (n)
 |        def solout(nr,xold,x,y,con,icomp,[nd]): return irtn
 |        Required arguments:
 |          nr : input int
 |          xold : input float
 |          x : input float
 |          y : input rank-1 array('d') with bounds (n)
 |          con : input rank-1 array('d') with bounds (5 * nd)
 |          icomp : input rank-1 array('i') with bounds (nd)
 |        Optional arguments:
 |          nd : input int, optional
 |          Default: (len(con))/(5)
 |        Return objects:
 |          irtn : int
 |  
 |  supports_solout = True
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from IntegratorBase:
 |  
 |  acquire_new_handle(self)
 |  
 |  check_handle(self)
 |  
 |  run_relax(self, f, jac, y0, t0, t1, f_params, jac_params)
 |      Integrate from t=t0 to t>=t1 and return (y1,t).
 |  
 |  step(self, f, jac, y0, t0, t1, f_params, jac_params)
 |      Make one integration step and return (y1,t1).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IntegratorBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from IntegratorBase:
 |  
 |  integrator_classes = [<class 'scipy.integrate._ode.vode'>, <class 'sci...
 |  
 |  istate = None
 |  
 |  scalar = <class 'float'>
 |      float(x) -> floating point number
 |      
 |      Convert a string or number to a floating point number, if possible.
 |  
 |  success = None
 |  
 |  supports_run_relax = None
 |  
 |  supports_step = None
",class,"('(self, rtol=1e-06, atol=1e-12, nsteps=500, max_step=0.0, first_step=0.0, safety=0.9, ifactor=10.0, dfactor=0.2, beta=0.0, method=None, verbosity=-1)',)",scipy,1.1.0,scipy.integrate._ode.dopri5,integrate._ode,dopri5,"Python Library Documentation: class dopri5 in module scipy.integrate._ode

class dopri5(IntegratorBase)
 |  Method resolution order:
 |      dopri5
 |      IntegratorBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, rtol=1e-06, atol=1e-12, nsteps=500, max_step=0.0, first_step=0.0, safety=0.9, ifactor=10.0, dfactor=0.2, beta=0.0, method=None, verbosity=-1)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  reset(self, n, has_jac)
 |      Prepare integrator for call: allocate memory, set flags, etc.
 |      n - number of equations.
 |      has_jac - if user has supplied function for evaluating Jacobian.
 |  
 |  run(self, f, jac, y0, t0, t1, f_params, jac_params)
 |      Integrate from t=t0 to t=t1 using y0 as an initial condition.
 |      Return 2-tuple (y1,t1) where y1 is the result and t=t1
 |      defines the stoppage coordinate of the result.
 |  
 |  set_solout(self, solout, complex=False)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  messages = {-4: 'problem is probably stiff (interrupted)', -3: 'step s...
 |  
 |  name = 'dopri5'
 |  
 |  runner = <fortran object>
 |      x,y,iwork,idid = dopri5(fcn,x,y,xend,rtol,atol,solout,iout,work,iwork,[fcn_extra_args,overwrite_y,solout_extra_args])
 |      
 |      Wrapper for ``dopri5``.
 |      
 |      Parameters
 |      ----------
 |      fcn : call-back function
 |      x : input float
 |      y : input rank-1 array('d') with bounds (n)
 |      xend : input float
 |      rtol : input rank-1 array('d') with bounds (*)
 |      atol : input rank-1 array('d') with bounds (*)
 |      solout : call-back function
 |      iout : input int
 |      work : input rank-1 array('d') with bounds (*)
 |      iwork : input rank-1 array('i') with bounds (*)
 |      
 |      Other Parameters
 |      ----------------
 |      fcn_extra_args : input tuple, optional
 |          Default: ()
 |      overwrite_y : input int, optional
 |          Default: 0
 |      solout_extra_args : input tuple, optional
 |          Default: ()
 |      
 |      Returns
 |      -------
 |      x : float
 |      y : rank-1 array('d') with bounds (n)
 |      iwork : rank-1 array('i') with bounds (*)
 |      idid : int
 |      
 |      Notes
 |      -----
 |      Call-back functions::
 |      
 |        def fcn(x,y): return f
 |        Required arguments:
 |          x : input float
 |          y : input rank-1 array('d') with bounds (n)
 |        Return objects:
 |          f : rank-1 array('d') with bounds (n)
 |        def solout(nr,xold,x,y,con,icomp,[nd]): return irtn
 |        Required arguments:
 |          nr : input int
 |          xold : input float
 |          x : input float
 |          y : input rank-1 array('d') with bounds (n)
 |          con : input rank-1 array('d') with bounds (5 * nd)
 |          icomp : input rank-1 array('i') with bounds (nd)
 |        Optional arguments:
 |          nd : input int, optional
 |          Default: (len(con))/(5)
 |        Return objects:
 |          irtn : int
 |  
 |  supports_solout = True
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from IntegratorBase:
 |  
 |  acquire_new_handle(self)
 |  
 |  check_handle(self)
 |  
 |  run_relax(self, f, jac, y0, t0, t1, f_params, jac_params)
 |      Integrate from t=t0 to t>=t1 and return (y1,t).
 |  
 |  step(self, f, jac, y0, t0, t1, f_params, jac_params)
 |      Make one integration step and return (y1,t1).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IntegratorBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from IntegratorBase:
 |  
 |  integrator_classes = [<class 'scipy.integrate._ode.vode'>, <class 'sci...
 |  
 |  istate = None
 |  
 |  scalar = <class 'float'>
 |      float(x) -> floating point number
 |      
 |      Convert a string or number to a floating point number, if possible.
 |  
 |  success = None
 |  
 |  supports_run_relax = None
 |  
 |  supports_step = None
",class,"('self', 'rtol', 'atol', 'nsteps', 'max_step', 'first_step', 'safety', 'ifactor', 'dfactor', 'beta', 'method', 'verbosity')","(nan, 1e-06, 1e-12, 500, 0.0, 0.0, 0.9, 10.0, 0.2, 0.0, None, -1)","(nan, 'float', 'float', 'int', 'float', 'float', 'float', 'float', 'float', 'float', 'NoneType', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, rtol=1e-06, atol=1e-12, nsteps=500, max_step=0.0, first_step=0.0, safety=0.9, ifactor=10.0, dfactor=0.2, beta=0.0, method=None, verbosity=-1)',)"
scipy,1.1.0,scipy.integrate._ode.find_integrator,integrate._ode,find_integrator,"Python Library Documentation: function find_integrator in module scipy.integrate._ode

find_integrator(name)
",function,"('(name)',)",scipy,1.1.0,scipy.integrate._ode.find_integrator,integrate._ode,find_integrator,"Python Library Documentation: function find_integrator in module scipy.integrate._ode

find_integrator(name)
",function,"('name',)","(nan,)","(nan,)","('arg_info',)","('(name)',)"
scipy,1.1.0,scipy.integrate._ode.imag,integrate._ode,imag,"Python Library Documentation: function imag in module numpy.lib.type_check

imag(val)
    Return the imaginary part of the complex argument.
    
    Parameters
    ----------
    val : array_like
        Input array.
    
    Returns
    -------
    out : ndarray or scalar
        The imaginary component of the complex argument. If `val` is real,
        the type of `val` is used for the output.  If `val` has complex
        elements, the returned type is float.
    
    See Also
    --------
    real, angle, real_if_close
    
    Examples
    --------
    >>> a = np.array([1+2j, 3+4j, 5+6j])
    >>> a.imag
    array([ 2.,  4.,  6.])
    >>> a.imag = np.array([8, 10, 12])
    >>> a
    array([ 1. +8.j,  3.+10.j,  5.+12.j])
    >>> np.imag(1 + 1j)
    1.0
",function,"('(val)',)",scipy,1.1.0,scipy.integrate._ode.imag,integrate._ode,imag,"Python Library Documentation: function imag in module numpy.lib.type_check

imag(val)
    Return the imaginary part of the complex argument.
    
    Parameters
    ----------
    val : array_like
        Input array.
    
    Returns
    -------
    out : ndarray or scalar
        The imaginary component of the complex argument. If `val` is real,
        the type of `val` is used for the output.  If `val` has complex
        elements, the returned type is float.
    
    See Also
    --------
    real, angle, real_if_close
    
    Examples
    --------
    >>> a = np.array([1+2j, 3+4j, 5+6j])
    >>> a.imag
    array([ 2.,  4.,  6.])
    >>> a.imag = np.array([8, 10, 12])
    >>> a
    array([ 1. +8.j,  3.+10.j,  5.+12.j])
    >>> np.imag(1 + 1j)
    1.0
",function,"('val',)","(nan,)","(nan,)","('arg_info',)","('(val)',)"
scipy,1.1.0,scipy.integrate._ode.int32,integrate._ode,int32,"Python Library Documentation: class int32 in module numpy

class int32(signedinteger)
 |  32-bit integer. Character code 'i'. C int compatible.
 |  
 |  Method resolution order:
 |      int32
 |      signedinteger
 |      integer
 |      number
 |      generic
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from integer:
 |  
 |  denominator
 |      denominator of value (1)
 |  
 |  numerator
 |      numerator of value (the value itself)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from generic:
 |  
 |  __array__(...)
 |      sc.__array__(|type) return 0-dim array
 |  
 |  __array_wrap__(...)
 |      sc.__array_wrap__(obj) return scalar from array
 |  
 |  __copy__(...)
 |  
 |  __deepcopy__(...)
 |  
 |  __format__(...)
 |      NumPy array scalar formatter
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __round__(...)
 |  
 |  __setstate__(...)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  all(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  any(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmax(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmin(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argsort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  astype(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  byteswap(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  choose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  clip(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  compress(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  conj(...)
 |  
 |  conjugate(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  copy(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumprod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumsum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  diagonal(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dump(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dumps(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  fill(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  flatten(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  getfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  item(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  itemset(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  max(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  mean(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  min(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  newbyteorder(...)
 |      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.
 |      
 |      The `new_order` code can be any from the following:
 |      
 |      * 'S' - swap dtype from current to opposite endian
 |      * {'<', 'L'} - little endian
 |      * {'>', 'B'} - big endian
 |      * {'=', 'N'} - native order
 |      * {'|', 'I'} - ignore (no change to byte order)
 |      
 |      Parameters
 |      ----------
 |      new_order : str, optional
 |          Byte order to force; a value from the byte order specifications
 |          above.  The default value ('S') results in swapping the current
 |          byte order. The code does a case-insensitive check on the first
 |          letter of `new_order` for the alternatives above.  For example,
 |          any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 |      
 |      
 |      Returns
 |      -------
 |      new_dtype : dtype
 |          New `dtype` object with the given change to the byte order.
 |  
 |  nonzero(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  prod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ptp(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  put(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ravel(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  repeat(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  reshape(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  resize(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  round(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  searchsorted(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setflags(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  squeeze(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  std(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  swapaxes(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  take(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tobytes(...)
 |  
 |  tofile(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tolist(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tostring(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  trace(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  transpose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  var(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  view(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from generic:
 |  
 |  T
 |      transpose
 |  
 |  __array_interface__
 |      Array protocol: Python side
 |  
 |  __array_priority__
 |      Array priority.
 |  
 |  __array_struct__
 |      Array protocol: struct
 |  
 |  base
 |      base object
 |  
 |  data
 |      pointer to start of data
 |  
 |  dtype
 |      get array data-descriptor
 |  
 |  flags
 |      integer value of flags
 |  
 |  flat
 |      a 1-d view of scalar
 |  
 |  imag
 |      imaginary part of scalar
 |  
 |  itemsize
 |      length of one element in bytes
 |  
 |  nbytes
 |      length of item in bytes
 |  
 |  ndim
 |      number of array dimensions
 |  
 |  real
 |      real part of scalar
 |  
 |  shape
 |      tuple of array dimensions
 |  
 |  size
 |      number of elements in the gentype
 |  
 |  strides
 |      tuple of bytes steps in each dimension
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.integrate._ode.int32,integrate._ode,int32,"Python Library Documentation: class int32 in module numpy

class int32(signedinteger)
 |  32-bit integer. Character code 'i'. C int compatible.
 |  
 |  Method resolution order:
 |      int32
 |      signedinteger
 |      integer
 |      number
 |      generic
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from integer:
 |  
 |  denominator
 |      denominator of value (1)
 |  
 |  numerator
 |      numerator of value (the value itself)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from generic:
 |  
 |  __array__(...)
 |      sc.__array__(|type) return 0-dim array
 |  
 |  __array_wrap__(...)
 |      sc.__array_wrap__(obj) return scalar from array
 |  
 |  __copy__(...)
 |  
 |  __deepcopy__(...)
 |  
 |  __format__(...)
 |      NumPy array scalar formatter
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __round__(...)
 |  
 |  __setstate__(...)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  all(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  any(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmax(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmin(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argsort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  astype(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  byteswap(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  choose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  clip(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  compress(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  conj(...)
 |  
 |  conjugate(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  copy(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumprod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumsum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  diagonal(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dump(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dumps(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  fill(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  flatten(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  getfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  item(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  itemset(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  max(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  mean(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  min(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  newbyteorder(...)
 |      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.
 |      
 |      The `new_order` code can be any from the following:
 |      
 |      * 'S' - swap dtype from current to opposite endian
 |      * {'<', 'L'} - little endian
 |      * {'>', 'B'} - big endian
 |      * {'=', 'N'} - native order
 |      * {'|', 'I'} - ignore (no change to byte order)
 |      
 |      Parameters
 |      ----------
 |      new_order : str, optional
 |          Byte order to force; a value from the byte order specifications
 |          above.  The default value ('S') results in swapping the current
 |          byte order. The code does a case-insensitive check on the first
 |          letter of `new_order` for the alternatives above.  For example,
 |          any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 |      
 |      
 |      Returns
 |      -------
 |      new_dtype : dtype
 |          New `dtype` object with the given change to the byte order.
 |  
 |  nonzero(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  prod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ptp(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  put(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ravel(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  repeat(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  reshape(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  resize(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  round(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  searchsorted(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setflags(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  squeeze(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  std(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  swapaxes(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  take(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tobytes(...)
 |  
 |  tofile(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tolist(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tostring(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  trace(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  transpose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  var(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  view(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from generic:
 |  
 |  T
 |      transpose
 |  
 |  __array_interface__
 |      Array protocol: Python side
 |  
 |  __array_priority__
 |      Array priority.
 |  
 |  __array_struct__
 |      Array protocol: struct
 |  
 |  base
 |      base object
 |  
 |  data
 |      pointer to start of data
 |  
 |  dtype
 |      get array data-descriptor
 |  
 |  flags
 |      integer value of flags
 |  
 |  flat
 |      a 1-d view of scalar
 |  
 |  imag
 |      imaginary part of scalar
 |  
 |  itemsize
 |      length of one element in bytes
 |  
 |  nbytes
 |      length of item in bytes
 |  
 |  ndim
 |      number of array dimensions
 |  
 |  real
 |      real part of scalar
 |  
 |  shape
 |      tuple of array dimensions
 |  
 |  size
 |      number of elements in the gentype
 |  
 |  strides
 |      tuple of bytes steps in each dimension
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.integrate._ode.isscalar,integrate._ode,isscalar,"Python Library Documentation: function isscalar in module numpy.core.numeric

isscalar(num)
    Returns True if the type of `num` is a scalar type.
    
    Parameters
    ----------
    num : any
        Input argument, can be of any type and shape.
    
    Returns
    -------
    val : bool
        True if `num` is a scalar type, False if it is not.
    
    Examples
    --------
    >>> np.isscalar(3.1)
    True
    >>> np.isscalar([3.1])
    False
    >>> np.isscalar(False)
    True
    >>> np.isscalar('numpy')
    True
    
    NumPy supports PEP 3141 numbers:
    
    >>> from fractions import Fraction
    >>> isscalar(Fraction(5, 17))
    True
    >>> from numbers import Number
    >>> isscalar(Number())
    True
",function,"('(num)',)",scipy,1.1.0,scipy.integrate._ode.isscalar,integrate._ode,isscalar,"Python Library Documentation: function isscalar in module numpy.core.numeric

isscalar(num)
    Returns True if the type of `num` is a scalar type.
    
    Parameters
    ----------
    num : any
        Input argument, can be of any type and shape.
    
    Returns
    -------
    val : bool
        True if `num` is a scalar type, False if it is not.
    
    Examples
    --------
    >>> np.isscalar(3.1)
    True
    >>> np.isscalar([3.1])
    False
    >>> np.isscalar(False)
    True
    >>> np.isscalar('numpy')
    True
    
    NumPy supports PEP 3141 numbers:
    
    >>> from fractions import Fraction
    >>> isscalar(Fraction(5, 17))
    True
    >>> from numbers import Number
    >>> isscalar(Number())
    True
",function,"('num',)","(nan,)","(nan,)","('arg_info',)","('(num)',)"
scipy,1.1.0,scipy.integrate._ode.lsoda,integrate._ode,lsoda,"Python Library Documentation: class lsoda in module scipy.integrate._ode

class lsoda(IntegratorBase)
 |  Method resolution order:
 |      lsoda
 |      IntegratorBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, with_jacobian=False, rtol=1e-06, atol=1e-12, lband=None, uband=None, nsteps=500, max_step=0.0, min_step=0.0, first_step=0.0, ixpr=0, max_hnil=0, max_order_ns=12, max_order_s=5, method=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  reset(self, n, has_jac)
 |      Prepare integrator for call: allocate memory, set flags, etc.
 |      n - number of equations.
 |      has_jac - if user has supplied function for evaluating Jacobian.
 |  
 |  run(self, f, jac, y0, t0, t1, f_params, jac_params)
 |      Integrate from t=t0 to t=t1 using y0 as an initial condition.
 |      Return 2-tuple (y1,t1) where y1 is the result and t=t1
 |      defines the stoppage coordinate of the result.
 |  
 |  run_relax(self, *args)
 |      Integrate from t=t0 to t>=t1 and return (y1,t).
 |  
 |  step(self, *args)
 |      Make one integration step and return (y1,t1).
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  active_global_handle = 0
 |  
 |  messages = {-7: 'Internal workspace insufficient to finish (internal e...
 |  
 |  runner = <fortran object>
 |      y,t,istate = lsoda(f,y,t,tout,rtol,atol,itask,istate,rwork,iwork,jac,jt,[f_extra_args,overwrite_y,jac_extra_args])
 |      
 |      Wrapper for ``lsoda``.
 |      
 |      Parameters
 |      ----------
 |      f : call-back function
 |      y : input rank-1 array('d') with bounds (neq)
 |      t : input float
 |      tout : input float
 |      rtol : input rank-1 array('d') with bounds (*)
 |      atol : input rank-1 array('d') with bounds (*)
 |      itask : input int
 |      istate : input int
 |      rwork : input rank-1 array('d') with bounds (lrw)
 |      iwork : input rank-1 array('i') with bounds (liw)
 |      jac : call-back function
 |      jt : input int
 |      
 |      Other Parameters
 |      ----------------
 |      f_extra_args : input tuple, optional
 |          Default: ()
 |      overwrite_y : input int, optional
 |          Default: 0
 |      jac_extra_args : input tuple, optional
 |          Default: ()
 |      
 |      Returns
 |      -------
 |      y : rank-1 array('d') with bounds (neq)
 |      t : float
 |      istate : int
 |      
 |      Notes
 |      -----
 |      Call-back functions::
 |      
 |        def f(t,y): return ydot
 |        Required arguments:
 |          t : input float
 |          y : input rank-1 array('d') with bounds (n)
 |        Return objects:
 |          ydot : rank-1 array('d') with bounds (n)
 |        def jac(t,y): return jac
 |        Required arguments:
 |          t : input float
 |          y : input rank-1 array('d') with bounds (n)
 |        Return objects:
 |          jac : rank-2 array('d') with bounds (nrowpd,n)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from IntegratorBase:
 |  
 |  acquire_new_handle(self)
 |  
 |  check_handle(self)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IntegratorBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from IntegratorBase:
 |  
 |  integrator_classes = [<class 'scipy.integrate._ode.vode'>, <class 'sci...
 |  
 |  istate = None
 |  
 |  scalar = <class 'float'>
 |      float(x) -> floating point number
 |      
 |      Convert a string or number to a floating point number, if possible.
 |  
 |  success = None
 |  
 |  supports_run_relax = None
 |  
 |  supports_solout = False
 |  
 |  supports_step = None
",class,"('(self, with_jacobian=False, rtol=1e-06, atol=1e-12, lband=None, uband=None, nsteps=500, max_step=0.0, min_step=0.0, first_step=0.0, ixpr=0, max_hnil=0, max_order_ns=12, max_order_s=5, method=None)',)",scipy,1.1.0,scipy.integrate._ode.lsoda,integrate._ode,lsoda,"Python Library Documentation: class lsoda in module scipy.integrate._ode

class lsoda(IntegratorBase)
 |  Method resolution order:
 |      lsoda
 |      IntegratorBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, with_jacobian=False, rtol=1e-06, atol=1e-12, lband=None, uband=None, nsteps=500, max_step=0.0, min_step=0.0, first_step=0.0, ixpr=0, max_hnil=0, max_order_ns=12, max_order_s=5, method=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  reset(self, n, has_jac)
 |      Prepare integrator for call: allocate memory, set flags, etc.
 |      n - number of equations.
 |      has_jac - if user has supplied function for evaluating Jacobian.
 |  
 |  run(self, f, jac, y0, t0, t1, f_params, jac_params)
 |      Integrate from t=t0 to t=t1 using y0 as an initial condition.
 |      Return 2-tuple (y1,t1) where y1 is the result and t=t1
 |      defines the stoppage coordinate of the result.
 |  
 |  run_relax(self, *args)
 |      Integrate from t=t0 to t>=t1 and return (y1,t).
 |  
 |  step(self, *args)
 |      Make one integration step and return (y1,t1).
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  active_global_handle = 0
 |  
 |  messages = {-7: 'Internal workspace insufficient to finish (internal e...
 |  
 |  runner = <fortran object>
 |      y,t,istate = lsoda(f,y,t,tout,rtol,atol,itask,istate,rwork,iwork,jac,jt,[f_extra_args,overwrite_y,jac_extra_args])
 |      
 |      Wrapper for ``lsoda``.
 |      
 |      Parameters
 |      ----------
 |      f : call-back function
 |      y : input rank-1 array('d') with bounds (neq)
 |      t : input float
 |      tout : input float
 |      rtol : input rank-1 array('d') with bounds (*)
 |      atol : input rank-1 array('d') with bounds (*)
 |      itask : input int
 |      istate : input int
 |      rwork : input rank-1 array('d') with bounds (lrw)
 |      iwork : input rank-1 array('i') with bounds (liw)
 |      jac : call-back function
 |      jt : input int
 |      
 |      Other Parameters
 |      ----------------
 |      f_extra_args : input tuple, optional
 |          Default: ()
 |      overwrite_y : input int, optional
 |          Default: 0
 |      jac_extra_args : input tuple, optional
 |          Default: ()
 |      
 |      Returns
 |      -------
 |      y : rank-1 array('d') with bounds (neq)
 |      t : float
 |      istate : int
 |      
 |      Notes
 |      -----
 |      Call-back functions::
 |      
 |        def f(t,y): return ydot
 |        Required arguments:
 |          t : input float
 |          y : input rank-1 array('d') with bounds (n)
 |        Return objects:
 |          ydot : rank-1 array('d') with bounds (n)
 |        def jac(t,y): return jac
 |        Required arguments:
 |          t : input float
 |          y : input rank-1 array('d') with bounds (n)
 |        Return objects:
 |          jac : rank-2 array('d') with bounds (nrowpd,n)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from IntegratorBase:
 |  
 |  acquire_new_handle(self)
 |  
 |  check_handle(self)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IntegratorBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from IntegratorBase:
 |  
 |  integrator_classes = [<class 'scipy.integrate._ode.vode'>, <class 'sci...
 |  
 |  istate = None
 |  
 |  scalar = <class 'float'>
 |      float(x) -> floating point number
 |      
 |      Convert a string or number to a floating point number, if possible.
 |  
 |  success = None
 |  
 |  supports_run_relax = None
 |  
 |  supports_solout = False
 |  
 |  supports_step = None
",class,"('self', 'with_jacobian', 'rtol', 'atol', 'lband', 'uband', 'nsteps', 'max_step', 'min_step', 'first_step', 'ixpr', 'max_hnil', 'max_order_ns', 'max_order_s', 'method')","(nan, False, 1e-06, 1e-12, None, None, 500, 0.0, 0.0, 0.0, 0, 0, 12, 5, None)","(nan, 'bool', 'float', 'float', 'NoneType', 'NoneType', 'int', 'float', 'float', 'float', 'int', 'int', 'int', 'int', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, with_jacobian=False, rtol=1e-06, atol=1e-12, lband=None, uband=None, nsteps=500, max_step=0.0, min_step=0.0, first_step=0.0, ixpr=0, max_hnil=0, max_order_ns=12, max_order_s=5, method=None)',)"
scipy,1.1.0,scipy.integrate._ode.ode,integrate._ode,ode,"Python Library Documentation: class ode in module scipy.integrate._ode

class ode(builtins.object)
 |  A generic interface class to numeric integrators.
 |  
 |  Solve an equation system :math:`y'(t) = f(t,y)` with (optional) ``jac = df/dy``.
 |  
 |  *Note*: The first two arguments of ``f(t, y, ...)`` are in the
 |  opposite order of the arguments in the system definition function used
 |  by `scipy.integrate.odeint`.
 |  
 |  Parameters
 |  ----------
 |  f : callable ``f(t, y, *f_args)``
 |      Right-hand side of the differential equation. t is a scalar,
 |      ``y.shape == (n,)``.
 |      ``f_args`` is set by calling ``set_f_params(*args)``.
 |      `f` should return a scalar, array or list (not a tuple).
 |  jac : callable ``jac(t, y, *jac_args)``, optional
 |      Jacobian of the right-hand side, ``jac[i,j] = d f[i] / d y[j]``.
 |      ``jac_args`` is set by calling ``set_jac_params(*args)``.
 |  
 |  Attributes
 |  ----------
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current variable values.
 |  
 |  See also
 |  --------
 |  odeint : an integrator with a simpler interface based on lsoda from ODEPACK
 |  quad : for finding the area under a curve
 |  
 |  Notes
 |  -----
 |  Available integrators are listed below. They can be selected using
 |  the `set_integrator` method.
 |  
 |  ""vode""
 |  
 |      Real-valued Variable-coefficient Ordinary Differential Equation
 |      solver, with fixed-leading-coefficient implementation. It provides
 |      implicit Adams method (for non-stiff problems) and a method based on
 |      backward differentiation formulas (BDF) (for stiff problems).
 |  
 |      Source: http://www.netlib.org/ode/vode.f
 |  
 |      .. warning::
 |  
 |         This integrator is not re-entrant. You cannot have two `ode`
 |         instances using the ""vode"" integrator at the same time.
 |  
 |      This integrator accepts the following parameters in `set_integrator`
 |      method of the `ode` class:
 |  
 |      - atol : float or sequence
 |        absolute tolerance for solution
 |      - rtol : float or sequence
 |        relative tolerance for solution
 |      - lband : None or int
 |      - uband : None or int
 |        Jacobian band width, jac[i,j] != 0 for i-lband <= j <= i+uband.
 |        Setting these requires your jac routine to return the jacobian
 |        in packed format, jac_packed[i-j+uband, j] = jac[i,j]. The
 |        dimension of the matrix must be (lband+uband+1, len(y)).
 |      - method: 'adams' or 'bdf'
 |        Which solver to use, Adams (non-stiff) or BDF (stiff)
 |      - with_jacobian : bool
 |        This option is only considered when the user has not supplied a
 |        Jacobian function and has not indicated (by setting either band)
 |        that the Jacobian is banded.  In this case, `with_jacobian` specifies
 |        whether the iteration method of the ODE solver's correction step is
 |        chord iteration with an internally generated full Jacobian or
 |        functional iteration with no Jacobian.
 |      - nsteps : int
 |        Maximum number of (internally defined) steps allowed during one
 |        call to the solver.
 |      - first_step : float
 |      - min_step : float
 |      - max_step : float
 |        Limits for the step sizes used by the integrator.
 |      - order : int
 |        Maximum order used by the integrator,
 |        order <= 12 for Adams, <= 5 for BDF.
 |  
 |  ""zvode""
 |  
 |      Complex-valued Variable-coefficient Ordinary Differential Equation
 |      solver, with fixed-leading-coefficient implementation.  It provides
 |      implicit Adams method (for non-stiff problems) and a method based on
 |      backward differentiation formulas (BDF) (for stiff problems).
 |  
 |      Source: http://www.netlib.org/ode/zvode.f
 |  
 |      .. warning::
 |  
 |         This integrator is not re-entrant. You cannot have two `ode`
 |         instances using the ""zvode"" integrator at the same time.
 |  
 |      This integrator accepts the same parameters in `set_integrator`
 |      as the ""vode"" solver.
 |  
 |      .. note::
 |  
 |          When using ZVODE for a stiff system, it should only be used for
 |          the case in which the function f is analytic, that is, when each f(i)
 |          is an analytic function of each y(j).  Analyticity means that the
 |          partial derivative df(i)/dy(j) is a unique complex number, and this
 |          fact is critical in the way ZVODE solves the dense or banded linear
 |          systems that arise in the stiff case.  For a complex stiff ODE system
 |          in which f is not analytic, ZVODE is likely to have convergence
 |          failures, and for this problem one should instead use DVODE on the
 |          equivalent real system (in the real and imaginary parts of y).
 |  
 |  ""lsoda""
 |  
 |      Real-valued Variable-coefficient Ordinary Differential Equation
 |      solver, with fixed-leading-coefficient implementation. It provides
 |      automatic method switching between implicit Adams method (for non-stiff
 |      problems) and a method based on backward differentiation formulas (BDF)
 |      (for stiff problems).
 |  
 |      Source: http://www.netlib.org/odepack
 |  
 |      .. warning::
 |  
 |         This integrator is not re-entrant. You cannot have two `ode`
 |         instances using the ""lsoda"" integrator at the same time.
 |  
 |      This integrator accepts the following parameters in `set_integrator`
 |      method of the `ode` class:
 |  
 |      - atol : float or sequence
 |        absolute tolerance for solution
 |      - rtol : float or sequence
 |        relative tolerance for solution
 |      - lband : None or int
 |      - uband : None or int
 |        Jacobian band width, jac[i,j] != 0 for i-lband <= j <= i+uband.
 |        Setting these requires your jac routine to return the jacobian
 |        in packed format, jac_packed[i-j+uband, j] = jac[i,j].
 |      - with_jacobian : bool
 |        *Not used.*
 |      - nsteps : int
 |        Maximum number of (internally defined) steps allowed during one
 |        call to the solver.
 |      - first_step : float
 |      - min_step : float
 |      - max_step : float
 |        Limits for the step sizes used by the integrator.
 |      - max_order_ns : int
 |        Maximum order used in the nonstiff case (default 12).
 |      - max_order_s : int
 |        Maximum order used in the stiff case (default 5).
 |      - max_hnil : int
 |        Maximum number of messages reporting too small step size (t + h = t)
 |        (default 0)
 |      - ixpr : int
 |        Whether to generate extra printing at method switches (default False).
 |  
 |  ""dopri5""
 |  
 |      This is an explicit runge-kutta method of order (4)5 due to Dormand &
 |      Prince (with stepsize control and dense output).
 |  
 |      Authors:
 |  
 |          E. Hairer and G. Wanner
 |          Universite de Geneve, Dept. de Mathematiques
 |          CH-1211 Geneve 24, Switzerland
 |          e-mail:  ernst.hairer@math.unige.ch, gerhard.wanner@math.unige.ch
 |  
 |      This code is described in [HNW93]_.
 |  
 |      This integrator accepts the following parameters in set_integrator()
 |      method of the ode class:
 |  
 |      - atol : float or sequence
 |        absolute tolerance for solution
 |      - rtol : float or sequence
 |        relative tolerance for solution
 |      - nsteps : int
 |        Maximum number of (internally defined) steps allowed during one
 |        call to the solver.
 |      - first_step : float
 |      - max_step : float
 |      - safety : float
 |        Safety factor on new step selection (default 0.9)
 |      - ifactor : float
 |      - dfactor : float
 |        Maximum factor to increase/decrease step size by in one step
 |      - beta : float
 |        Beta parameter for stabilised step size control.
 |      - verbosity : int
 |        Switch for printing messages (< 0 for no messages).
 |  
 |  ""dop853""
 |  
 |      This is an explicit runge-kutta method of order 8(5,3) due to Dormand
 |      & Prince (with stepsize control and dense output).
 |  
 |      Options and references the same as ""dopri5"".
 |  
 |  Examples
 |  --------
 |  
 |  A problem to integrate and the corresponding jacobian:
 |  
 |  >>> from scipy.integrate import ode
 |  >>>
 |  >>> y0, t0 = [1.0j, 2.0], 0
 |  >>>
 |  >>> def f(t, y, arg1):
 |  ...     return [1j*arg1*y[0] + y[1], -arg1*y[1]**2]
 |  >>> def jac(t, y, arg1):
 |  ...     return [[1j*arg1, 1], [0, -arg1*2*y[1]]]
 |  
 |  The integration:
 |  
 |  >>> r = ode(f, jac).set_integrator('zvode', method='bdf')
 |  >>> r.set_initial_value(y0, t0).set_f_params(2.0).set_jac_params(2.0)
 |  >>> t1 = 10
 |  >>> dt = 1
 |  >>> while r.successful() and r.t < t1:
 |  ...     print(r.t+dt, r.integrate(r.t+dt))
 |  1 [-0.71038232+0.23749653j  0.40000271+0.j        ]
 |  2.0 [0.19098503-0.52359246j 0.22222356+0.j        ]
 |  3.0 [0.47153208+0.52701229j 0.15384681+0.j        ]
 |  4.0 [-0.61905937+0.30726255j  0.11764744+0.j        ]
 |  5.0 [0.02340997-0.61418799j 0.09523835+0.j        ]
 |  6.0 [0.58643071+0.339819j 0.08000018+0.j      ]
 |  7.0 [-0.52070105+0.44525141j  0.06896565+0.j        ]
 |  8.0 [-0.15986733-0.61234476j  0.06060616+0.j        ]
 |  9.0 [0.64850462+0.15048982j 0.05405414+0.j        ]
 |  10.0 [-0.38404699+0.56382299j  0.04878055+0.j        ]
 |  
 |  References
 |  ----------
 |  .. [HNW93] E. Hairer, S.P. Norsett and G. Wanner, Solving Ordinary
 |      Differential Equations i. Nonstiff Problems. 2nd edition.
 |      Springer Series in Computational Mathematics,
 |      Springer-Verlag (1993)
 |  
 |  Methods defined here:
 |  
 |  __init__(self, f, jac=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  get_return_code(self)
 |      Extracts the return code for the integration to enable better control
 |      if the integration fails.
 |      
 |      In general, a return code > 0 implies success while a return code < 0
 |      implies failure.
 |      
 |      Notes
 |      -----
 |      This section describes possible return codes and their meaning, for available
 |      integrators that can be selected by `set_integrator` method.
 |      
 |      ""vode""
 |      
 |      ===========  =======
 |      Return Code  Message
 |      ===========  =======
 |      2            Integration successful.
 |      -1           Excess work done on this call. (Perhaps wrong MF.)
 |      -2           Excess accuracy requested. (Tolerances too small.)
 |      -3           Illegal input detected. (See printed message.)
 |      -4           Repeated error test failures. (Check all input.)
 |      -5           Repeated convergence failures. (Perhaps bad Jacobian
 |                   supplied or wrong choice of MF or tolerances.)
 |      -6           Error weight became zero during problem. (Solution
 |                   component i vanished, and ATOL or ATOL(i) = 0.)
 |      ===========  =======
 |      
 |      ""zvode""
 |      
 |      ===========  =======
 |      Return Code  Message
 |      ===========  =======
 |      2            Integration successful.
 |      -1           Excess work done on this call. (Perhaps wrong MF.)
 |      -2           Excess accuracy requested. (Tolerances too small.)
 |      -3           Illegal input detected. (See printed message.)
 |      -4           Repeated error test failures. (Check all input.)
 |      -5           Repeated convergence failures. (Perhaps bad Jacobian
 |                   supplied or wrong choice of MF or tolerances.)
 |      -6           Error weight became zero during problem. (Solution
 |                   component i vanished, and ATOL or ATOL(i) = 0.)
 |      ===========  =======
 |      
 |      ""dopri5""
 |      
 |      ===========  =======
 |      Return Code  Message
 |      ===========  =======
 |      1            Integration successful.
 |      2            Integration successful (interrupted by solout).
 |      -1           Input is not consistent.
 |      -2           Larger nsteps is needed.
 |      -3           Step size becomes too small.
 |      -4           Problem is probably stiff (interrupted).
 |      ===========  =======
 |      
 |      ""dop853""
 |      
 |      ===========  =======
 |      Return Code  Message
 |      ===========  =======
 |      1            Integration successful.
 |      2            Integration successful (interrupted by solout).
 |      -1           Input is not consistent.
 |      -2           Larger nsteps is needed.
 |      -3           Step size becomes too small.
 |      -4           Problem is probably stiff (interrupted).
 |      ===========  =======
 |      
 |      ""lsoda""
 |      
 |      ===========  =======
 |      Return Code  Message
 |      ===========  =======
 |      2            Integration successful.
 |      -1           Excess work done on this call (perhaps wrong Dfun type).
 |      -2           Excess accuracy requested (tolerances too small).
 |      -3           Illegal input detected (internal error).
 |      -4           Repeated error test failures (internal error).
 |      -5           Repeated convergence failures (perhaps bad Jacobian or tolerances).
 |      -6           Error weight became zero during problem.
 |      -7           Internal workspace insufficient to finish (internal error).
 |      ===========  =======
 |  
 |  integrate(self, t, step=False, relax=False)
 |      Find y=y(t), set y as an initial condition, and return y.
 |      
 |      Parameters
 |      ----------
 |      t : float
 |          The endpoint of the integration step.
 |      step : bool
 |          If True, and if the integrator supports the step method,
 |          then perform a single integration step and return.
 |          This parameter is provided in order to expose internals of
 |          the implementation, and should not be changed from its default
 |          value in most cases.
 |      relax : bool
 |          If True and if the integrator supports the run_relax method,
 |          then integrate until t_1 >= t and return. ``relax`` is not
 |          referenced if ``step=True``.
 |          This parameter is provided in order to expose internals of
 |          the implementation, and should not be changed from its default
 |          value in most cases.
 |      
 |      Returns
 |      -------
 |      y : float
 |          The integrated value at t
 |  
 |  set_f_params(self, *args)
 |      Set extra parameters for user-supplied function f.
 |  
 |  set_initial_value(self, y, t=0.0)
 |      Set initial conditions y(t) = y.
 |  
 |  set_integrator(self, name, **integrator_params)
 |      Set integrator by name.
 |      
 |      Parameters
 |      ----------
 |      name : str
 |          Name of the integrator.
 |      integrator_params
 |          Additional parameters for the integrator.
 |  
 |  set_jac_params(self, *args)
 |      Set extra parameters for user-supplied function jac.
 |  
 |  set_solout(self, solout)
 |      Set callable to be called at every successful integration step.
 |      
 |      Parameters
 |      ----------
 |      solout : callable
 |          ``solout(t, y)`` is called at each internal integrator step,
 |          t is a scalar providing the current independent position
 |          y is the current soloution ``y.shape == (n,)``
 |          solout should return -1 to stop integration
 |          otherwise it should return None or 0
 |  
 |  successful(self)
 |      Check if integration was successful.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  y
",class,"('(self, f, jac=None)',)",scipy,1.1.0,scipy.integrate._ode.ode,integrate._ode,ode,"Python Library Documentation: class ode in module scipy.integrate._ode

class ode(builtins.object)
 |  A generic interface class to numeric integrators.
 |  
 |  Solve an equation system :math:`y'(t) = f(t,y)` with (optional) ``jac = df/dy``.
 |  
 |  *Note*: The first two arguments of ``f(t, y, ...)`` are in the
 |  opposite order of the arguments in the system definition function used
 |  by `scipy.integrate.odeint`.
 |  
 |  Parameters
 |  ----------
 |  f : callable ``f(t, y, *f_args)``
 |      Right-hand side of the differential equation. t is a scalar,
 |      ``y.shape == (n,)``.
 |      ``f_args`` is set by calling ``set_f_params(*args)``.
 |      `f` should return a scalar, array or list (not a tuple).
 |  jac : callable ``jac(t, y, *jac_args)``, optional
 |      Jacobian of the right-hand side, ``jac[i,j] = d f[i] / d y[j]``.
 |      ``jac_args`` is set by calling ``set_jac_params(*args)``.
 |  
 |  Attributes
 |  ----------
 |  t : float
 |      Current time.
 |  y : ndarray
 |      Current variable values.
 |  
 |  See also
 |  --------
 |  odeint : an integrator with a simpler interface based on lsoda from ODEPACK
 |  quad : for finding the area under a curve
 |  
 |  Notes
 |  -----
 |  Available integrators are listed below. They can be selected using
 |  the `set_integrator` method.
 |  
 |  ""vode""
 |  
 |      Real-valued Variable-coefficient Ordinary Differential Equation
 |      solver, with fixed-leading-coefficient implementation. It provides
 |      implicit Adams method (for non-stiff problems) and a method based on
 |      backward differentiation formulas (BDF) (for stiff problems).
 |  
 |      Source: http://www.netlib.org/ode/vode.f
 |  
 |      .. warning::
 |  
 |         This integrator is not re-entrant. You cannot have two `ode`
 |         instances using the ""vode"" integrator at the same time.
 |  
 |      This integrator accepts the following parameters in `set_integrator`
 |      method of the `ode` class:
 |  
 |      - atol : float or sequence
 |        absolute tolerance for solution
 |      - rtol : float or sequence
 |        relative tolerance for solution
 |      - lband : None or int
 |      - uband : None or int
 |        Jacobian band width, jac[i,j] != 0 for i-lband <= j <= i+uband.
 |        Setting these requires your jac routine to return the jacobian
 |        in packed format, jac_packed[i-j+uband, j] = jac[i,j]. The
 |        dimension of the matrix must be (lband+uband+1, len(y)).
 |      - method: 'adams' or 'bdf'
 |        Which solver to use, Adams (non-stiff) or BDF (stiff)
 |      - with_jacobian : bool
 |        This option is only considered when the user has not supplied a
 |        Jacobian function and has not indicated (by setting either band)
 |        that the Jacobian is banded.  In this case, `with_jacobian` specifies
 |        whether the iteration method of the ODE solver's correction step is
 |        chord iteration with an internally generated full Jacobian or
 |        functional iteration with no Jacobian.
 |      - nsteps : int
 |        Maximum number of (internally defined) steps allowed during one
 |        call to the solver.
 |      - first_step : float
 |      - min_step : float
 |      - max_step : float
 |        Limits for the step sizes used by the integrator.
 |      - order : int
 |        Maximum order used by the integrator,
 |        order <= 12 for Adams, <= 5 for BDF.
 |  
 |  ""zvode""
 |  
 |      Complex-valued Variable-coefficient Ordinary Differential Equation
 |      solver, with fixed-leading-coefficient implementation.  It provides
 |      implicit Adams method (for non-stiff problems) and a method based on
 |      backward differentiation formulas (BDF) (for stiff problems).
 |  
 |      Source: http://www.netlib.org/ode/zvode.f
 |  
 |      .. warning::
 |  
 |         This integrator is not re-entrant. You cannot have two `ode`
 |         instances using the ""zvode"" integrator at the same time.
 |  
 |      This integrator accepts the same parameters in `set_integrator`
 |      as the ""vode"" solver.
 |  
 |      .. note::
 |  
 |          When using ZVODE for a stiff system, it should only be used for
 |          the case in which the function f is analytic, that is, when each f(i)
 |          is an analytic function of each y(j).  Analyticity means that the
 |          partial derivative df(i)/dy(j) is a unique complex number, and this
 |          fact is critical in the way ZVODE solves the dense or banded linear
 |          systems that arise in the stiff case.  For a complex stiff ODE system
 |          in which f is not analytic, ZVODE is likely to have convergence
 |          failures, and for this problem one should instead use DVODE on the
 |          equivalent real system (in the real and imaginary parts of y).
 |  
 |  ""lsoda""
 |  
 |      Real-valued Variable-coefficient Ordinary Differential Equation
 |      solver, with fixed-leading-coefficient implementation. It provides
 |      automatic method switching between implicit Adams method (for non-stiff
 |      problems) and a method based on backward differentiation formulas (BDF)
 |      (for stiff problems).
 |  
 |      Source: http://www.netlib.org/odepack
 |  
 |      .. warning::
 |  
 |         This integrator is not re-entrant. You cannot have two `ode`
 |         instances using the ""lsoda"" integrator at the same time.
 |  
 |      This integrator accepts the following parameters in `set_integrator`
 |      method of the `ode` class:
 |  
 |      - atol : float or sequence
 |        absolute tolerance for solution
 |      - rtol : float or sequence
 |        relative tolerance for solution
 |      - lband : None or int
 |      - uband : None or int
 |        Jacobian band width, jac[i,j] != 0 for i-lband <= j <= i+uband.
 |        Setting these requires your jac routine to return the jacobian
 |        in packed format, jac_packed[i-j+uband, j] = jac[i,j].
 |      - with_jacobian : bool
 |        *Not used.*
 |      - nsteps : int
 |        Maximum number of (internally defined) steps allowed during one
 |        call to the solver.
 |      - first_step : float
 |      - min_step : float
 |      - max_step : float
 |        Limits for the step sizes used by the integrator.
 |      - max_order_ns : int
 |        Maximum order used in the nonstiff case (default 12).
 |      - max_order_s : int
 |        Maximum order used in the stiff case (default 5).
 |      - max_hnil : int
 |        Maximum number of messages reporting too small step size (t + h = t)
 |        (default 0)
 |      - ixpr : int
 |        Whether to generate extra printing at method switches (default False).
 |  
 |  ""dopri5""
 |  
 |      This is an explicit runge-kutta method of order (4)5 due to Dormand &
 |      Prince (with stepsize control and dense output).
 |  
 |      Authors:
 |  
 |          E. Hairer and G. Wanner
 |          Universite de Geneve, Dept. de Mathematiques
 |          CH-1211 Geneve 24, Switzerland
 |          e-mail:  ernst.hairer@math.unige.ch, gerhard.wanner@math.unige.ch
 |  
 |      This code is described in [HNW93]_.
 |  
 |      This integrator accepts the following parameters in set_integrator()
 |      method of the ode class:
 |  
 |      - atol : float or sequence
 |        absolute tolerance for solution
 |      - rtol : float or sequence
 |        relative tolerance for solution
 |      - nsteps : int
 |        Maximum number of (internally defined) steps allowed during one
 |        call to the solver.
 |      - first_step : float
 |      - max_step : float
 |      - safety : float
 |        Safety factor on new step selection (default 0.9)
 |      - ifactor : float
 |      - dfactor : float
 |        Maximum factor to increase/decrease step size by in one step
 |      - beta : float
 |        Beta parameter for stabilised step size control.
 |      - verbosity : int
 |        Switch for printing messages (< 0 for no messages).
 |  
 |  ""dop853""
 |  
 |      This is an explicit runge-kutta method of order 8(5,3) due to Dormand
 |      & Prince (with stepsize control and dense output).
 |  
 |      Options and references the same as ""dopri5"".
 |  
 |  Examples
 |  --------
 |  
 |  A problem to integrate and the corresponding jacobian:
 |  
 |  >>> from scipy.integrate import ode
 |  >>>
 |  >>> y0, t0 = [1.0j, 2.0], 0
 |  >>>
 |  >>> def f(t, y, arg1):
 |  ...     return [1j*arg1*y[0] + y[1], -arg1*y[1]**2]
 |  >>> def jac(t, y, arg1):
 |  ...     return [[1j*arg1, 1], [0, -arg1*2*y[1]]]
 |  
 |  The integration:
 |  
 |  >>> r = ode(f, jac).set_integrator('zvode', method='bdf')
 |  >>> r.set_initial_value(y0, t0).set_f_params(2.0).set_jac_params(2.0)
 |  >>> t1 = 10
 |  >>> dt = 1
 |  >>> while r.successful() and r.t < t1:
 |  ...     print(r.t+dt, r.integrate(r.t+dt))
 |  1 [-0.71038232+0.23749653j  0.40000271+0.j        ]
 |  2.0 [0.19098503-0.52359246j 0.22222356+0.j        ]
 |  3.0 [0.47153208+0.52701229j 0.15384681+0.j        ]
 |  4.0 [-0.61905937+0.30726255j  0.11764744+0.j        ]
 |  5.0 [0.02340997-0.61418799j 0.09523835+0.j        ]
 |  6.0 [0.58643071+0.339819j 0.08000018+0.j      ]
 |  7.0 [-0.52070105+0.44525141j  0.06896565+0.j        ]
 |  8.0 [-0.15986733-0.61234476j  0.06060616+0.j        ]
 |  9.0 [0.64850462+0.15048982j 0.05405414+0.j        ]
 |  10.0 [-0.38404699+0.56382299j  0.04878055+0.j        ]
 |  
 |  References
 |  ----------
 |  .. [HNW93] E. Hairer, S.P. Norsett and G. Wanner, Solving Ordinary
 |      Differential Equations i. Nonstiff Problems. 2nd edition.
 |      Springer Series in Computational Mathematics,
 |      Springer-Verlag (1993)
 |  
 |  Methods defined here:
 |  
 |  __init__(self, f, jac=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  get_return_code(self)
 |      Extracts the return code for the integration to enable better control
 |      if the integration fails.
 |      
 |      In general, a return code > 0 implies success while a return code < 0
 |      implies failure.
 |      
 |      Notes
 |      -----
 |      This section describes possible return codes and their meaning, for available
 |      integrators that can be selected by `set_integrator` method.
 |      
 |      ""vode""
 |      
 |      ===========  =======
 |      Return Code  Message
 |      ===========  =======
 |      2            Integration successful.
 |      -1           Excess work done on this call. (Perhaps wrong MF.)
 |      -2           Excess accuracy requested. (Tolerances too small.)
 |      -3           Illegal input detected. (See printed message.)
 |      -4           Repeated error test failures. (Check all input.)
 |      -5           Repeated convergence failures. (Perhaps bad Jacobian
 |                   supplied or wrong choice of MF or tolerances.)
 |      -6           Error weight became zero during problem. (Solution
 |                   component i vanished, and ATOL or ATOL(i) = 0.)
 |      ===========  =======
 |      
 |      ""zvode""
 |      
 |      ===========  =======
 |      Return Code  Message
 |      ===========  =======
 |      2            Integration successful.
 |      -1           Excess work done on this call. (Perhaps wrong MF.)
 |      -2           Excess accuracy requested. (Tolerances too small.)
 |      -3           Illegal input detected. (See printed message.)
 |      -4           Repeated error test failures. (Check all input.)
 |      -5           Repeated convergence failures. (Perhaps bad Jacobian
 |                   supplied or wrong choice of MF or tolerances.)
 |      -6           Error weight became zero during problem. (Solution
 |                   component i vanished, and ATOL or ATOL(i) = 0.)
 |      ===========  =======
 |      
 |      ""dopri5""
 |      
 |      ===========  =======
 |      Return Code  Message
 |      ===========  =======
 |      1            Integration successful.
 |      2            Integration successful (interrupted by solout).
 |      -1           Input is not consistent.
 |      -2           Larger nsteps is needed.
 |      -3           Step size becomes too small.
 |      -4           Problem is probably stiff (interrupted).
 |      ===========  =======
 |      
 |      ""dop853""
 |      
 |      ===========  =======
 |      Return Code  Message
 |      ===========  =======
 |      1            Integration successful.
 |      2            Integration successful (interrupted by solout).
 |      -1           Input is not consistent.
 |      -2           Larger nsteps is needed.
 |      -3           Step size becomes too small.
 |      -4           Problem is probably stiff (interrupted).
 |      ===========  =======
 |      
 |      ""lsoda""
 |      
 |      ===========  =======
 |      Return Code  Message
 |      ===========  =======
 |      2            Integration successful.
 |      -1           Excess work done on this call (perhaps wrong Dfun type).
 |      -2           Excess accuracy requested (tolerances too small).
 |      -3           Illegal input detected (internal error).
 |      -4           Repeated error test failures (internal error).
 |      -5           Repeated convergence failures (perhaps bad Jacobian or tolerances).
 |      -6           Error weight became zero during problem.
 |      -7           Internal workspace insufficient to finish (internal error).
 |      ===========  =======
 |  
 |  integrate(self, t, step=False, relax=False)
 |      Find y=y(t), set y as an initial condition, and return y.
 |      
 |      Parameters
 |      ----------
 |      t : float
 |          The endpoint of the integration step.
 |      step : bool
 |          If True, and if the integrator supports the step method,
 |          then perform a single integration step and return.
 |          This parameter is provided in order to expose internals of
 |          the implementation, and should not be changed from its default
 |          value in most cases.
 |      relax : bool
 |          If True and if the integrator supports the run_relax method,
 |          then integrate until t_1 >= t and return. ``relax`` is not
 |          referenced if ``step=True``.
 |          This parameter is provided in order to expose internals of
 |          the implementation, and should not be changed from its default
 |          value in most cases.
 |      
 |      Returns
 |      -------
 |      y : float
 |          The integrated value at t
 |  
 |  set_f_params(self, *args)
 |      Set extra parameters for user-supplied function f.
 |  
 |  set_initial_value(self, y, t=0.0)
 |      Set initial conditions y(t) = y.
 |  
 |  set_integrator(self, name, **integrator_params)
 |      Set integrator by name.
 |      
 |      Parameters
 |      ----------
 |      name : str
 |          Name of the integrator.
 |      integrator_params
 |          Additional parameters for the integrator.
 |  
 |  set_jac_params(self, *args)
 |      Set extra parameters for user-supplied function jac.
 |  
 |  set_solout(self, solout)
 |      Set callable to be called at every successful integration step.
 |      
 |      Parameters
 |      ----------
 |      solout : callable
 |          ``solout(t, y)`` is called at each internal integrator step,
 |          t is a scalar providing the current independent position
 |          y is the current soloution ``y.shape == (n,)``
 |          solout should return -1 to stop integration
 |          otherwise it should return None or 0
 |  
 |  successful(self)
 |      Check if integration was successful.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  y
",class,"('self', 'f', 'jac')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(self, f, jac=None)',)"
scipy,1.1.0,scipy.integrate._ode.real,integrate._ode,real,"Python Library Documentation: function real in module numpy.lib.type_check

real(val)
    Return the real part of the complex argument.
    
    Parameters
    ----------
    val : array_like
        Input array.
    
    Returns
    -------
    out : ndarray or scalar
        The real component of the complex argument. If `val` is real, the type
        of `val` is used for the output.  If `val` has complex elements, the
        returned type is float.
    
    See Also
    --------
    real_if_close, imag, angle
    
    Examples
    --------
    >>> a = np.array([1+2j, 3+4j, 5+6j])
    >>> a.real
    array([ 1.,  3.,  5.])
    >>> a.real = 9
    >>> a
    array([ 9.+2.j,  9.+4.j,  9.+6.j])
    >>> a.real = np.array([9, 8, 7])
    >>> a
    array([ 9.+2.j,  8.+4.j,  7.+6.j])
    >>> np.real(1 + 1j)
    1.0
",function,"('(val)',)",scipy,1.1.0,scipy.integrate._ode.real,integrate._ode,real,"Python Library Documentation: function real in module numpy.lib.type_check

real(val)
    Return the real part of the complex argument.
    
    Parameters
    ----------
    val : array_like
        Input array.
    
    Returns
    -------
    out : ndarray or scalar
        The real component of the complex argument. If `val` is real, the type
        of `val` is used for the output.  If `val` has complex elements, the
        returned type is float.
    
    See Also
    --------
    real_if_close, imag, angle
    
    Examples
    --------
    >>> a = np.array([1+2j, 3+4j, 5+6j])
    >>> a.real
    array([ 1.,  3.,  5.])
    >>> a.real = 9
    >>> a
    array([ 9.+2.j,  9.+4.j,  9.+6.j])
    >>> a.real = np.array([9, 8, 7])
    >>> a
    array([ 9.+2.j,  8.+4.j,  7.+6.j])
    >>> np.real(1 + 1j)
    1.0
",function,"('val',)","(nan,)","(nan,)","('arg_info',)","('(val)',)"
scipy,1.1.0,scipy.integrate._ode.vode,integrate._ode,vode,"Python Library Documentation: class vode in module scipy.integrate._ode

class vode(IntegratorBase)
 |  Method resolution order:
 |      vode
 |      IntegratorBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, method='adams', with_jacobian=False, rtol=1e-06, atol=1e-12, lband=None, uband=None, order=12, nsteps=500, max_step=0.0, min_step=0.0, first_step=0.0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  reset(self, n, has_jac)
 |      Prepare integrator for call: allocate memory, set flags, etc.
 |      n - number of equations.
 |      has_jac - if user has supplied function for evaluating Jacobian.
 |  
 |  run(self, f, jac, y0, t0, t1, f_params, jac_params)
 |      Integrate from t=t0 to t=t1 using y0 as an initial condition.
 |      Return 2-tuple (y1,t1) where y1 is the result and t=t1
 |      defines the stoppage coordinate of the result.
 |  
 |  run_relax(self, *args)
 |      Integrate from t=t0 to t>=t1 and return (y1,t).
 |  
 |  step(self, *args)
 |      Make one integration step and return (y1,t1).
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  active_global_handle = 0
 |  
 |  messages = {-6: 'Error weight became zero during problem. (Solution co...
 |  
 |  runner = <fortran object>
 |      y,t,istate = dvode(f,jac,y,t,tout,rtol,atol,itask,istate,rwork,iwork,mf,[f_extra_args,jac_extra_args,overwrite_y])
 |      
 |      Wrapper for ``dvode``.
 |      
 |      Parameters
 |      ----------
 |      f : call-back function
 |      jac : call-back function
 |      y : input rank-1 array('d') with bounds (neq)
 |      t : input float
 |      tout : input float
 |      rtol : input rank-1 array('d') with bounds (*)
 |      atol : input rank-1 array('d') with bounds (*)
 |      itask : input int
 |      istate : input int
 |      rwork : input rank-1 array('d') with bounds (lrw)
 |      iwork : input rank-1 array('i') with bounds (liw)
 |      mf : input int
 |      
 |      Other Parameters
 |      ----------------
 |      f_extra_args : input tuple, optional
 |          Default: ()
 |      jac_extra_args : input tuple, optional
 |          Default: ()
 |      overwrite_y : input int, optional
 |          Default: 0
 |      
 |      Returns
 |      -------
 |      y : rank-1 array('d') with bounds (neq)
 |      t : float
 |      istate : int
 |      
 |      Notes
 |      -----
 |      Call-back functions::
 |      
 |        def f(t,y): return ydot
 |        Required arguments:
 |          t : input float
 |          y : input rank-1 array('d') with bounds (n)
 |        Return objects:
 |          ydot : rank-1 array('d') with bounds (n)
 |        def jac(t,y): return jac
 |        Required arguments:
 |          t : input float
 |          y : input rank-1 array('d') with bounds (n)
 |        Return objects:
 |          jac : rank-2 array('d') with bounds (nrowpd,n)
 |  
 |  supports_run_relax = 1
 |  
 |  supports_step = 1
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from IntegratorBase:
 |  
 |  acquire_new_handle(self)
 |  
 |  check_handle(self)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IntegratorBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from IntegratorBase:
 |  
 |  integrator_classes = [<class 'scipy.integrate._ode.vode'>, <class 'sci...
 |  
 |  istate = None
 |  
 |  scalar = <class 'float'>
 |      float(x) -> floating point number
 |      
 |      Convert a string or number to a floating point number, if possible.
 |  
 |  success = None
 |  
 |  supports_solout = False
",class,"(""(self, method='adams', with_jacobian=False, rtol=1e-06, atol=1e-12, lband=None, uband=None, order=12, nsteps=500, max_step=0.0, min_step=0.0, first_step=0.0)"",)",scipy,1.1.0,scipy.integrate._ode.vode,integrate._ode,vode,"Python Library Documentation: class vode in module scipy.integrate._ode

class vode(IntegratorBase)
 |  Method resolution order:
 |      vode
 |      IntegratorBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, method='adams', with_jacobian=False, rtol=1e-06, atol=1e-12, lband=None, uband=None, order=12, nsteps=500, max_step=0.0, min_step=0.0, first_step=0.0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  reset(self, n, has_jac)
 |      Prepare integrator for call: allocate memory, set flags, etc.
 |      n - number of equations.
 |      has_jac - if user has supplied function for evaluating Jacobian.
 |  
 |  run(self, f, jac, y0, t0, t1, f_params, jac_params)
 |      Integrate from t=t0 to t=t1 using y0 as an initial condition.
 |      Return 2-tuple (y1,t1) where y1 is the result and t=t1
 |      defines the stoppage coordinate of the result.
 |  
 |  run_relax(self, *args)
 |      Integrate from t=t0 to t>=t1 and return (y1,t).
 |  
 |  step(self, *args)
 |      Make one integration step and return (y1,t1).
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  active_global_handle = 0
 |  
 |  messages = {-6: 'Error weight became zero during problem. (Solution co...
 |  
 |  runner = <fortran object>
 |      y,t,istate = dvode(f,jac,y,t,tout,rtol,atol,itask,istate,rwork,iwork,mf,[f_extra_args,jac_extra_args,overwrite_y])
 |      
 |      Wrapper for ``dvode``.
 |      
 |      Parameters
 |      ----------
 |      f : call-back function
 |      jac : call-back function
 |      y : input rank-1 array('d') with bounds (neq)
 |      t : input float
 |      tout : input float
 |      rtol : input rank-1 array('d') with bounds (*)
 |      atol : input rank-1 array('d') with bounds (*)
 |      itask : input int
 |      istate : input int
 |      rwork : input rank-1 array('d') with bounds (lrw)
 |      iwork : input rank-1 array('i') with bounds (liw)
 |      mf : input int
 |      
 |      Other Parameters
 |      ----------------
 |      f_extra_args : input tuple, optional
 |          Default: ()
 |      jac_extra_args : input tuple, optional
 |          Default: ()
 |      overwrite_y : input int, optional
 |          Default: 0
 |      
 |      Returns
 |      -------
 |      y : rank-1 array('d') with bounds (neq)
 |      t : float
 |      istate : int
 |      
 |      Notes
 |      -----
 |      Call-back functions::
 |      
 |        def f(t,y): return ydot
 |        Required arguments:
 |          t : input float
 |          y : input rank-1 array('d') with bounds (n)
 |        Return objects:
 |          ydot : rank-1 array('d') with bounds (n)
 |        def jac(t,y): return jac
 |        Required arguments:
 |          t : input float
 |          y : input rank-1 array('d') with bounds (n)
 |        Return objects:
 |          jac : rank-2 array('d') with bounds (nrowpd,n)
 |  
 |  supports_run_relax = 1
 |  
 |  supports_step = 1
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from IntegratorBase:
 |  
 |  acquire_new_handle(self)
 |  
 |  check_handle(self)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IntegratorBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from IntegratorBase:
 |  
 |  integrator_classes = [<class 'scipy.integrate._ode.vode'>, <class 'sci...
 |  
 |  istate = None
 |  
 |  scalar = <class 'float'>
 |      float(x) -> floating point number
 |      
 |      Convert a string or number to a floating point number, if possible.
 |  
 |  success = None
 |  
 |  supports_solout = False
",class,"('self', 'method', 'with_jacobian', 'rtol', 'atol', 'lband', 'uband', 'order', 'nsteps', 'max_step', 'min_step', 'first_step')","(nan, 'adams', False, 1e-06, 1e-12, None, None, 12, 500, 0.0, 0.0, 0.0)","(nan, 'str', 'bool', 'float', 'float', 'NoneType', 'NoneType', 'int', 'int', 'float', 'float', 'float')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(self, method='adams', with_jacobian=False, rtol=1e-06, atol=1e-12, lband=None, uband=None, order=12, nsteps=500, max_step=0.0, min_step=0.0, first_step=0.0)"",)"
scipy,1.1.0,scipy.integrate._ode.vstack,integrate._ode,vstack,"Python Library Documentation: function vstack in module numpy.core.shape_base

vstack(tup)
    Stack arrays in sequence vertically (row wise).
    
    This is equivalent to concatenation along the first axis after 1-D arrays
    of shape `(N,)` have been reshaped to `(1,N)`. Rebuilds arrays divided by
    `vsplit`.
    
    This function makes most sense for arrays with up to 3 dimensions. For
    instance, for pixel-data with a height (first axis), width (second axis),
    and r/g/b channels (third axis). The functions `concatenate`, `stack` and
    `block` provide more general stacking and concatenation operations.
    
    Parameters
    ----------
    tup : sequence of ndarrays
        The arrays must have the same shape along all but the first axis.
        1-D arrays must have the same length.
    
    Returns
    -------
    stacked : ndarray
        The array formed by stacking the given arrays, will be at least 2-D.
    
    See Also
    --------
    stack : Join a sequence of arrays along a new axis.
    hstack : Stack arrays in sequence horizontally (column wise).
    dstack : Stack arrays in sequence depth wise (along third dimension).
    concatenate : Join a sequence of arrays along an existing axis.
    vsplit : Split array into a list of multiple sub-arrays vertically.
    block : Assemble arrays from blocks.
    
    Examples
    --------
    >>> a = np.array([1, 2, 3])
    >>> b = np.array([2, 3, 4])
    >>> np.vstack((a,b))
    array([[1, 2, 3],
           [2, 3, 4]])
    
    >>> a = np.array([[1], [2], [3]])
    >>> b = np.array([[2], [3], [4]])
    >>> np.vstack((a,b))
    array([[1],
           [2],
           [3],
           [2],
           [3],
           [4]])
",function,"('(tup)',)",scipy,1.1.0,scipy.integrate._ode.vstack,integrate._ode,vstack,"Python Library Documentation: function vstack in module numpy.core.shape_base

vstack(tup)
    Stack arrays in sequence vertically (row wise).
    
    This is equivalent to concatenation along the first axis after 1-D arrays
    of shape `(N,)` have been reshaped to `(1,N)`. Rebuilds arrays divided by
    `vsplit`.
    
    This function makes most sense for arrays with up to 3 dimensions. For
    instance, for pixel-data with a height (first axis), width (second axis),
    and r/g/b channels (third axis). The functions `concatenate`, `stack` and
    `block` provide more general stacking and concatenation operations.
    
    Parameters
    ----------
    tup : sequence of ndarrays
        The arrays must have the same shape along all but the first axis.
        1-D arrays must have the same length.
    
    Returns
    -------
    stacked : ndarray
        The array formed by stacking the given arrays, will be at least 2-D.
    
    See Also
    --------
    stack : Join a sequence of arrays along a new axis.
    hstack : Stack arrays in sequence horizontally (column wise).
    dstack : Stack arrays in sequence depth wise (along third dimension).
    concatenate : Join a sequence of arrays along an existing axis.
    vsplit : Split array into a list of multiple sub-arrays vertically.
    block : Assemble arrays from blocks.
    
    Examples
    --------
    >>> a = np.array([1, 2, 3])
    >>> b = np.array([2, 3, 4])
    >>> np.vstack((a,b))
    array([[1, 2, 3],
           [2, 3, 4]])
    
    >>> a = np.array([[1], [2], [3]])
    >>> b = np.array([[2], [3], [4]])
    >>> np.vstack((a,b))
    array([[1],
           [2],
           [3],
           [2],
           [3],
           [4]])
",function,"('tup',)","(nan,)","(nan,)","('arg_info',)","('(tup)',)"
scipy,1.1.0,scipy.integrate._ode.zvode,integrate._ode,zvode,"Python Library Documentation: class zvode in module scipy.integrate._ode

class zvode(vode)
 |  Method resolution order:
 |      zvode
 |      vode
 |      IntegratorBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  reset(self, n, has_jac)
 |      Prepare integrator for call: allocate memory, set flags, etc.
 |      n - number of equations.
 |      has_jac - if user has supplied function for evaluating Jacobian.
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  active_global_handle = 0
 |  
 |  runner = <fortran object>
 |      y,t,istate = zvode(f,jac,y,t,tout,rtol,atol,itask,istate,zwork,rwork,iwork,mf,[f_extra_args,jac_extra_args,overwrite_y])
 |      
 |      Wrapper for ``zvode``.
 |      
 |      Parameters
 |      ----------
 |      f : call-back function
 |      jac : call-back function
 |      y : input rank-1 array('D') with bounds (neq)
 |      t : input float
 |      tout : input float
 |      rtol : input rank-1 array('d') with bounds (*)
 |      atol : input rank-1 array('d') with bounds (*)
 |      itask : input int
 |      istate : input int
 |      zwork : input rank-1 array('D') with bounds (lzw)
 |      rwork : input rank-1 array('d') with bounds (lrw)
 |      iwork : input rank-1 array('i') with bounds (liw)
 |      mf : input int
 |      
 |      Other Parameters
 |      ----------------
 |      f_extra_args : input tuple, optional
 |          Default: ()
 |      jac_extra_args : input tuple, optional
 |          Default: ()
 |      overwrite_y : input int, optional
 |          Default: 0
 |      
 |      Returns
 |      -------
 |      y : rank-1 array('D') with bounds (neq)
 |      t : float
 |      istate : int
 |      
 |      Notes
 |      -----
 |      Call-back functions::
 |      
 |        def f(t,y): return ydot
 |        Required arguments:
 |          t : input float
 |          y : input rank-1 array('D') with bounds (n)
 |        Return objects:
 |          ydot : rank-1 array('D') with bounds (n)
 |        def jac(t,y): return jac
 |        Required arguments:
 |          t : input float
 |          y : input rank-1 array('D') with bounds (n)
 |        Return objects:
 |          jac : rank-2 array('D') with bounds (nrowpd,n)
 |  
 |  scalar = <class 'complex'>
 |      complex(real[, imag]) -> complex number
 |      
 |      Create a complex number from a real part and an optional imaginary part.
 |      This is equivalent to (real + imag*1j) where imag defaults to 0.
 |  
 |  supports_run_relax = 1
 |  
 |  supports_step = 1
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from vode:
 |  
 |  __init__(self, method='adams', with_jacobian=False, rtol=1e-06, atol=1e-12, lband=None, uband=None, order=12, nsteps=500, max_step=0.0, min_step=0.0, first_step=0.0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  run(self, f, jac, y0, t0, t1, f_params, jac_params)
 |      Integrate from t=t0 to t=t1 using y0 as an initial condition.
 |      Return 2-tuple (y1,t1) where y1 is the result and t=t1
 |      defines the stoppage coordinate of the result.
 |  
 |  run_relax(self, *args)
 |      Integrate from t=t0 to t>=t1 and return (y1,t).
 |  
 |  step(self, *args)
 |      Make one integration step and return (y1,t1).
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from vode:
 |  
 |  messages = {-6: 'Error weight became zero during problem. (Solution co...
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from IntegratorBase:
 |  
 |  acquire_new_handle(self)
 |  
 |  check_handle(self)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IntegratorBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from IntegratorBase:
 |  
 |  integrator_classes = [<class 'scipy.integrate._ode.vode'>, <class 'sci...
 |  
 |  istate = None
 |  
 |  success = None
 |  
 |  supports_solout = False
",class,"(""(self, method='adams', with_jacobian=False, rtol=1e-06, atol=1e-12, lband=None, uband=None, order=12, nsteps=500, max_step=0.0, min_step=0.0, first_step=0.0)"",)",scipy,1.1.0,scipy.integrate._ode.zvode,integrate._ode,zvode,"Python Library Documentation: class zvode in module scipy.integrate._ode

class zvode(vode)
 |  Method resolution order:
 |      zvode
 |      vode
 |      IntegratorBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  reset(self, n, has_jac)
 |      Prepare integrator for call: allocate memory, set flags, etc.
 |      n - number of equations.
 |      has_jac - if user has supplied function for evaluating Jacobian.
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  active_global_handle = 0
 |  
 |  runner = <fortran object>
 |      y,t,istate = zvode(f,jac,y,t,tout,rtol,atol,itask,istate,zwork,rwork,iwork,mf,[f_extra_args,jac_extra_args,overwrite_y])
 |      
 |      Wrapper for ``zvode``.
 |      
 |      Parameters
 |      ----------
 |      f : call-back function
 |      jac : call-back function
 |      y : input rank-1 array('D') with bounds (neq)
 |      t : input float
 |      tout : input float
 |      rtol : input rank-1 array('d') with bounds (*)
 |      atol : input rank-1 array('d') with bounds (*)
 |      itask : input int
 |      istate : input int
 |      zwork : input rank-1 array('D') with bounds (lzw)
 |      rwork : input rank-1 array('d') with bounds (lrw)
 |      iwork : input rank-1 array('i') with bounds (liw)
 |      mf : input int
 |      
 |      Other Parameters
 |      ----------------
 |      f_extra_args : input tuple, optional
 |          Default: ()
 |      jac_extra_args : input tuple, optional
 |          Default: ()
 |      overwrite_y : input int, optional
 |          Default: 0
 |      
 |      Returns
 |      -------
 |      y : rank-1 array('D') with bounds (neq)
 |      t : float
 |      istate : int
 |      
 |      Notes
 |      -----
 |      Call-back functions::
 |      
 |        def f(t,y): return ydot
 |        Required arguments:
 |          t : input float
 |          y : input rank-1 array('D') with bounds (n)
 |        Return objects:
 |          ydot : rank-1 array('D') with bounds (n)
 |        def jac(t,y): return jac
 |        Required arguments:
 |          t : input float
 |          y : input rank-1 array('D') with bounds (n)
 |        Return objects:
 |          jac : rank-2 array('D') with bounds (nrowpd,n)
 |  
 |  scalar = <class 'complex'>
 |      complex(real[, imag]) -> complex number
 |      
 |      Create a complex number from a real part and an optional imaginary part.
 |      This is equivalent to (real + imag*1j) where imag defaults to 0.
 |  
 |  supports_run_relax = 1
 |  
 |  supports_step = 1
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from vode:
 |  
 |  __init__(self, method='adams', with_jacobian=False, rtol=1e-06, atol=1e-12, lband=None, uband=None, order=12, nsteps=500, max_step=0.0, min_step=0.0, first_step=0.0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  run(self, f, jac, y0, t0, t1, f_params, jac_params)
 |      Integrate from t=t0 to t=t1 using y0 as an initial condition.
 |      Return 2-tuple (y1,t1) where y1 is the result and t=t1
 |      defines the stoppage coordinate of the result.
 |  
 |  run_relax(self, *args)
 |      Integrate from t=t0 to t>=t1 and return (y1,t).
 |  
 |  step(self, *args)
 |      Make one integration step and return (y1,t1).
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from vode:
 |  
 |  messages = {-6: 'Error weight became zero during problem. (Solution co...
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from IntegratorBase:
 |  
 |  acquire_new_handle(self)
 |  
 |  check_handle(self)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from IntegratorBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from IntegratorBase:
 |  
 |  integrator_classes = [<class 'scipy.integrate._ode.vode'>, <class 'sci...
 |  
 |  istate = None
 |  
 |  success = None
 |  
 |  supports_solout = False
",class,"('self', 'method', 'with_jacobian', 'rtol', 'atol', 'lband', 'uband', 'order', 'nsteps', 'max_step', 'min_step', 'first_step')","(nan, 'adams', False, 1e-06, 1e-12, None, None, 12, 500, 0.0, 0.0, 0.0)","(nan, 'str', 'bool', 'float', 'float', 'NoneType', 'NoneType', 'int', 'int', 'float', 'float', 'float')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(self, method='adams', with_jacobian=False, rtol=1e-06, atol=1e-12, lband=None, uband=None, order=12, nsteps=500, max_step=0.0, min_step=0.0, first_step=0.0)"",)"
scipy,1.1.0,scipy.integrate._odepack.error,integrate._odepack,error,"Python Library Documentation: class error

class error(builtins.Exception)
 |  Common base class for all non-exit exceptions.
 |  
 |  Method resolution order:
 |      error
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.integrate._odepack.error,integrate._odepack,error,"Python Library Documentation: class error

class error(builtins.Exception)
 |  Common base class for all non-exit exceptions.
 |  
 |  Method resolution order:
 |      error
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.integrate._quadpack.error,integrate._quadpack,error,"Python Library Documentation: class error

class error(builtins.Exception)
 |  Common base class for all non-exit exceptions.
 |  
 |  Method resolution order:
 |      error
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.integrate._quadpack.error,integrate._quadpack,error,"Python Library Documentation: class error

class error(builtins.Exception)
 |  Common base class for all non-exit exceptions.
 |  
 |  Method resolution order:
 |      error
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.integrate.odepack.ODEintWarning,integrate.odepack,ODEintWarning,"Python Library Documentation: class ODEintWarning in module scipy.integrate.odepack

class ODEintWarning(builtins.Warning)
 |  Base class for warning categories.
 |  
 |  Method resolution order:
 |      ODEintWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Warning:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.integrate.odepack.ODEintWarning,integrate.odepack,ODEintWarning,"Python Library Documentation: class ODEintWarning in module scipy.integrate.odepack

class ODEintWarning(builtins.Warning)
 |  Base class for warning categories.
 |  
 |  Method resolution order:
 |      ODEintWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Warning:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.integrate.odepack.copy,integrate.odepack,copy,"Python Library Documentation: function copy in module copy

copy(x)
    Shallow copy operation on arbitrary Python objects.
    
    See the module's __doc__ string for more info.
",function,"('(x)',)",scipy,1.1.0,scipy.integrate.odepack.copy,integrate.odepack,copy,"Python Library Documentation: function copy in module copy

copy(x)
    Shallow copy operation on arbitrary Python objects.
    
    See the module's __doc__ string for more info.
",function,"('x',)","(nan,)","(nan,)","('arg_info',)","('(x)',)"
scipy,1.1.0,scipy.integrate.odepack.odeint,integrate.odepack,odeint,"Python Library Documentation: function odeint in module scipy.integrate.odepack

odeint(func, y0, t, args=(), Dfun=None, col_deriv=0, full_output=0, ml=None, mu=None, rtol=None, atol=None, tcrit=None, h0=0.0, hmax=0.0, hmin=0.0, ixpr=0, mxstep=0, mxhnil=0, mxordn=12, mxords=5, printmessg=0, tfirst=False)
    Integrate a system of ordinary differential equations.
    
    .. note:: For new code, use `scipy.integrate.solve_ivp` to solve a
              differential equation.
    
    Solve a system of ordinary differential equations using lsoda from the
    FORTRAN library odepack.
    
    Solves the initial value problem for stiff or non-stiff systems
    of first order ode-s::
    
        dy/dt = func(y, t, ...)  [or func(t, y, ...)]
    
    where y can be a vector.
    
    .. note:: By default, the required order of the first two arguments of
              `func` are in the opposite order of the arguments in the system
              definition function used by the `scipy.integrate.ode` class and
              the function `scipy.integrate.solve_ivp`.  To use a function with
              the signature ``func(t, y, ...)``, the argument `tfirst` must be
              set to ``True``.
    
    Parameters
    ----------
    func : callable(y, t, ...) or callable(t, y, ...)
        Computes the derivative of y at t.
        If the signature is ``callable(t, y, ...)``, then the argument
        `tfirst` must be set ``True``.
    y0 : array
        Initial condition on y (can be a vector).
    t : array
        A sequence of time points for which to solve for y.  The initial
        value point should be the first element of this sequence.
    args : tuple, optional
        Extra arguments to pass to function.
    Dfun : callable(y, t, ...) or callable(t, y, ...)
        Gradient (Jacobian) of `func`.
        If the signature is ``callable(t, y, ...)``, then the argument
        `tfirst` must be set ``True``.
    col_deriv : bool, optional
        True if `Dfun` defines derivatives down columns (faster),
        otherwise `Dfun` should define derivatives across rows.
    full_output : bool, optional
        True if to return a dictionary of optional outputs as the second output
    printmessg : bool, optional
        Whether to print the convergence message
    tfirst: bool, optional
        If True, the first two arguments of `func` (and `Dfun`, if given)
        must ``t, y`` instead of the default ``y, t``.
    
        .. versionadded:: 1.1.0
    
    Returns
    -------
    y : array, shape (len(t), len(y0))
        Array containing the value of y for each desired time in t,
        with the initial value `y0` in the first row.
    infodict : dict, only returned if full_output == True
        Dictionary containing additional output information
    
        =======  ============================================================
        key      meaning
        =======  ============================================================
        'hu'     vector of step sizes successfully used for each time step.
        'tcur'   vector with the value of t reached for each time step.
                 (will always be at least as large as the input times).
        'tolsf'  vector of tolerance scale factors, greater than 1.0,
                 computed when a request for too much accuracy was detected.
        'tsw'    value of t at the time of the last method switch
                 (given for each time step)
        'nst'    cumulative number of time steps
        'nfe'    cumulative number of function evaluations for each time step
        'nje'    cumulative number of jacobian evaluations for each time step
        'nqu'    a vector of method orders for each successful step.
        'imxer'  index of the component of largest magnitude in the
                 weighted local error vector (e / ewt) on an error return, -1
                 otherwise.
        'lenrw'  the length of the double work array required.
        'leniw'  the length of integer work array required.
        'mused'  a vector of method indicators for each successful time step:
                 1: adams (nonstiff), 2: bdf (stiff)
        =======  ============================================================
    
    Other Parameters
    ----------------
    ml, mu : int, optional
        If either of these are not None or non-negative, then the
        Jacobian is assumed to be banded.  These give the number of
        lower and upper non-zero diagonals in this banded matrix.
        For the banded case, `Dfun` should return a matrix whose
        rows contain the non-zero bands (starting with the lowest diagonal).
        Thus, the return matrix `jac` from `Dfun` should have shape
        ``(ml + mu + 1, len(y0))`` when ``ml >=0`` or ``mu >=0``.
        The data in `jac` must be stored such that ``jac[i - j + mu, j]``
        holds the derivative of the `i`th equation with respect to the `j`th
        state variable.  If `col_deriv` is True, the transpose of this
        `jac` must be returned.
    rtol, atol : float, optional
        The input parameters `rtol` and `atol` determine the error
        control performed by the solver.  The solver will control the
        vector, e, of estimated local errors in y, according to an
        inequality of the form ``max-norm of (e / ewt) <= 1``,
        where ewt is a vector of positive error weights computed as
        ``ewt = rtol * abs(y) + atol``.
        rtol and atol can be either vectors the same length as y or scalars.
        Defaults to 1.49012e-8.
    tcrit : ndarray, optional
        Vector of critical points (e.g. singularities) where integration
        care should be taken.
    h0 : float, (0: solver-determined), optional
        The step size to be attempted on the first step.
    hmax : float, (0: solver-determined), optional
        The maximum absolute step size allowed.
    hmin : float, (0: solver-determined), optional
        The minimum absolute step size allowed.
    ixpr : bool, optional
        Whether to generate extra printing at method switches.
    mxstep : int, (0: solver-determined), optional
        Maximum number of (internally defined) steps allowed for each
        integration point in t.
    mxhnil : int, (0: solver-determined), optional
        Maximum number of messages printed.
    mxordn : int, (0: solver-determined), optional
        Maximum order to be allowed for the non-stiff (Adams) method.
    mxords : int, (0: solver-determined), optional
        Maximum order to be allowed for the stiff (BDF) method.
    
    See Also
    --------
    solve_ivp : Solve an initial value problem for a system of ODEs.
    ode : a more object-oriented integrator based on VODE.
    quad : for finding the area under a curve.
    
    Examples
    --------
    The second order differential equation for the angle `theta` of a
    pendulum acted on by gravity with friction can be written::
    
        theta''(t) + b*theta'(t) + c*sin(theta(t)) = 0
    
    where `b` and `c` are positive constants, and a prime (') denotes a
    derivative.  To solve this equation with `odeint`, we must first convert
    it to a system of first order equations.  By defining the angular
    velocity ``omega(t) = theta'(t)``, we obtain the system::
    
        theta'(t) = omega(t)
        omega'(t) = -b*omega(t) - c*sin(theta(t))
    
    Let `y` be the vector [`theta`, `omega`].  We implement this system
    in python as:
    
    >>> def pend(y, t, b, c):
    ...     theta, omega = y
    ...     dydt = [omega, -b*omega - c*np.sin(theta)]
    ...     return dydt
    ...
    
    We assume the constants are `b` = 0.25 and `c` = 5.0:
    
    >>> b = 0.25
    >>> c = 5.0
    
    For initial conditions, we assume the pendulum is nearly vertical
    with `theta(0)` = `pi` - 0.1, and is initially at rest, so
    `omega(0)` = 0.  Then the vector of initial conditions is
    
    >>> y0 = [np.pi - 0.1, 0.0]
    
    We will generate a solution at 101 evenly spaced samples in the interval
    0 <= `t` <= 10.  So our array of times is:
    
    >>> t = np.linspace(0, 10, 101)
    
    Call `odeint` to generate the solution.  To pass the parameters
    `b` and `c` to `pend`, we give them to `odeint` using the `args`
    argument.
    
    >>> from scipy.integrate import odeint
    >>> sol = odeint(pend, y0, t, args=(b, c))
    
    The solution is an array with shape (101, 2).  The first column
    is `theta(t)`, and the second is `omega(t)`.  The following code
    plots both components.
    
    >>> import matplotlib.pyplot as plt
    >>> plt.plot(t, sol[:, 0], 'b', label='theta(t)')
    >>> plt.plot(t, sol[:, 1], 'g', label='omega(t)')
    >>> plt.legend(loc='best')
    >>> plt.xlabel('t')
    >>> plt.grid()
    >>> plt.show()
",function,"('(func, y0, t, args=(), Dfun=None, col_deriv=0, full_output=0, ml=None, mu=None, rtol=None, atol=None, tcrit=None, h0=0.0, hmax=0.0, hmin=0.0, ixpr=0, mxstep=0, mxhnil=0, mxordn=12, mxords=5, printmessg=0, tfirst=False)',)",scipy,1.1.0,scipy.integrate.odepack.odeint,integrate.odepack,odeint,"Python Library Documentation: function odeint in module scipy.integrate.odepack

odeint(func, y0, t, args=(), Dfun=None, col_deriv=0, full_output=0, ml=None, mu=None, rtol=None, atol=None, tcrit=None, h0=0.0, hmax=0.0, hmin=0.0, ixpr=0, mxstep=0, mxhnil=0, mxordn=12, mxords=5, printmessg=0, tfirst=False)
    Integrate a system of ordinary differential equations.
    
    .. note:: For new code, use `scipy.integrate.solve_ivp` to solve a
              differential equation.
    
    Solve a system of ordinary differential equations using lsoda from the
    FORTRAN library odepack.
    
    Solves the initial value problem for stiff or non-stiff systems
    of first order ode-s::
    
        dy/dt = func(y, t, ...)  [or func(t, y, ...)]
    
    where y can be a vector.
    
    .. note:: By default, the required order of the first two arguments of
              `func` are in the opposite order of the arguments in the system
              definition function used by the `scipy.integrate.ode` class and
              the function `scipy.integrate.solve_ivp`.  To use a function with
              the signature ``func(t, y, ...)``, the argument `tfirst` must be
              set to ``True``.
    
    Parameters
    ----------
    func : callable(y, t, ...) or callable(t, y, ...)
        Computes the derivative of y at t.
        If the signature is ``callable(t, y, ...)``, then the argument
        `tfirst` must be set ``True``.
    y0 : array
        Initial condition on y (can be a vector).
    t : array
        A sequence of time points for which to solve for y.  The initial
        value point should be the first element of this sequence.
    args : tuple, optional
        Extra arguments to pass to function.
    Dfun : callable(y, t, ...) or callable(t, y, ...)
        Gradient (Jacobian) of `func`.
        If the signature is ``callable(t, y, ...)``, then the argument
        `tfirst` must be set ``True``.
    col_deriv : bool, optional
        True if `Dfun` defines derivatives down columns (faster),
        otherwise `Dfun` should define derivatives across rows.
    full_output : bool, optional
        True if to return a dictionary of optional outputs as the second output
    printmessg : bool, optional
        Whether to print the convergence message
    tfirst: bool, optional
        If True, the first two arguments of `func` (and `Dfun`, if given)
        must ``t, y`` instead of the default ``y, t``.
    
        .. versionadded:: 1.1.0
    
    Returns
    -------
    y : array, shape (len(t), len(y0))
        Array containing the value of y for each desired time in t,
        with the initial value `y0` in the first row.
    infodict : dict, only returned if full_output == True
        Dictionary containing additional output information
    
        =======  ============================================================
        key      meaning
        =======  ============================================================
        'hu'     vector of step sizes successfully used for each time step.
        'tcur'   vector with the value of t reached for each time step.
                 (will always be at least as large as the input times).
        'tolsf'  vector of tolerance scale factors, greater than 1.0,
                 computed when a request for too much accuracy was detected.
        'tsw'    value of t at the time of the last method switch
                 (given for each time step)
        'nst'    cumulative number of time steps
        'nfe'    cumulative number of function evaluations for each time step
        'nje'    cumulative number of jacobian evaluations for each time step
        'nqu'    a vector of method orders for each successful step.
        'imxer'  index of the component of largest magnitude in the
                 weighted local error vector (e / ewt) on an error return, -1
                 otherwise.
        'lenrw'  the length of the double work array required.
        'leniw'  the length of integer work array required.
        'mused'  a vector of method indicators for each successful time step:
                 1: adams (nonstiff), 2: bdf (stiff)
        =======  ============================================================
    
    Other Parameters
    ----------------
    ml, mu : int, optional
        If either of these are not None or non-negative, then the
        Jacobian is assumed to be banded.  These give the number of
        lower and upper non-zero diagonals in this banded matrix.
        For the banded case, `Dfun` should return a matrix whose
        rows contain the non-zero bands (starting with the lowest diagonal).
        Thus, the return matrix `jac` from `Dfun` should have shape
        ``(ml + mu + 1, len(y0))`` when ``ml >=0`` or ``mu >=0``.
        The data in `jac` must be stored such that ``jac[i - j + mu, j]``
        holds the derivative of the `i`th equation with respect to the `j`th
        state variable.  If `col_deriv` is True, the transpose of this
        `jac` must be returned.
    rtol, atol : float, optional
        The input parameters `rtol` and `atol` determine the error
        control performed by the solver.  The solver will control the
        vector, e, of estimated local errors in y, according to an
        inequality of the form ``max-norm of (e / ewt) <= 1``,
        where ewt is a vector of positive error weights computed as
        ``ewt = rtol * abs(y) + atol``.
        rtol and atol can be either vectors the same length as y or scalars.
        Defaults to 1.49012e-8.
    tcrit : ndarray, optional
        Vector of critical points (e.g. singularities) where integration
        care should be taken.
    h0 : float, (0: solver-determined), optional
        The step size to be attempted on the first step.
    hmax : float, (0: solver-determined), optional
        The maximum absolute step size allowed.
    hmin : float, (0: solver-determined), optional
        The minimum absolute step size allowed.
    ixpr : bool, optional
        Whether to generate extra printing at method switches.
    mxstep : int, (0: solver-determined), optional
        Maximum number of (internally defined) steps allowed for each
        integration point in t.
    mxhnil : int, (0: solver-determined), optional
        Maximum number of messages printed.
    mxordn : int, (0: solver-determined), optional
        Maximum order to be allowed for the non-stiff (Adams) method.
    mxords : int, (0: solver-determined), optional
        Maximum order to be allowed for the stiff (BDF) method.
    
    See Also
    --------
    solve_ivp : Solve an initial value problem for a system of ODEs.
    ode : a more object-oriented integrator based on VODE.
    quad : for finding the area under a curve.
    
    Examples
    --------
    The second order differential equation for the angle `theta` of a
    pendulum acted on by gravity with friction can be written::
    
        theta''(t) + b*theta'(t) + c*sin(theta(t)) = 0
    
    where `b` and `c` are positive constants, and a prime (') denotes a
    derivative.  To solve this equation with `odeint`, we must first convert
    it to a system of first order equations.  By defining the angular
    velocity ``omega(t) = theta'(t)``, we obtain the system::
    
        theta'(t) = omega(t)
        omega'(t) = -b*omega(t) - c*sin(theta(t))
    
    Let `y` be the vector [`theta`, `omega`].  We implement this system
    in python as:
    
    >>> def pend(y, t, b, c):
    ...     theta, omega = y
    ...     dydt = [omega, -b*omega - c*np.sin(theta)]
    ...     return dydt
    ...
    
    We assume the constants are `b` = 0.25 and `c` = 5.0:
    
    >>> b = 0.25
    >>> c = 5.0
    
    For initial conditions, we assume the pendulum is nearly vertical
    with `theta(0)` = `pi` - 0.1, and is initially at rest, so
    `omega(0)` = 0.  Then the vector of initial conditions is
    
    >>> y0 = [np.pi - 0.1, 0.0]
    
    We will generate a solution at 101 evenly spaced samples in the interval
    0 <= `t` <= 10.  So our array of times is:
    
    >>> t = np.linspace(0, 10, 101)
    
    Call `odeint` to generate the solution.  To pass the parameters
    `b` and `c` to `pend`, we give them to `odeint` using the `args`
    argument.
    
    >>> from scipy.integrate import odeint
    >>> sol = odeint(pend, y0, t, args=(b, c))
    
    The solution is an array with shape (101, 2).  The first column
    is `theta(t)`, and the second is `omega(t)`.  The following code
    plots both components.
    
    >>> import matplotlib.pyplot as plt
    >>> plt.plot(t, sol[:, 0], 'b', label='theta(t)')
    >>> plt.plot(t, sol[:, 1], 'g', label='omega(t)')
    >>> plt.legend(loc='best')
    >>> plt.xlabel('t')
    >>> plt.grid()
    >>> plt.show()
",function,"('func', 'y0', 't', 'args', 'Dfun', 'col_deriv', 'full_output', 'ml', 'mu', 'rtol', 'atol', 'tcrit', 'h0', 'hmax', 'hmin', 'ixpr', 'mxstep', 'mxhnil', 'mxordn', 'mxords', 'printmessg', 'tfirst')","(nan, nan, nan, (), None, 0, 0, None, None, None, None, None, 0.0, 0.0, 0.0, 0, 0, 0, 12, 5, 0, False)","(nan, nan, nan, 'tuple', 'NoneType', 'int', 'int', 'NoneType', 'NoneType', 'NoneType', 'NoneType', 'NoneType', 'float', 'float', 'float', 'int', 'int', 'int', 'int', 'int', 'int', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(func, y0, t, args=(), Dfun=None, col_deriv=0, full_output=0, ml=None, mu=None, rtol=None, atol=None, tcrit=None, h0=0.0, hmax=0.0, hmin=0.0, ixpr=0, mxstep=0, mxhnil=0, mxordn=12, mxords=5, printmessg=0, tfirst=False)',)"
scipy,1.1.0,scipy.integrate.quadpack.IntegrationWarning,integrate.quadpack,IntegrationWarning,"Python Library Documentation: class IntegrationWarning in module scipy.integrate.quadpack

class IntegrationWarning(builtins.UserWarning)
 |  Warning on issues during integration.
 |  
 |  Method resolution order:
 |      IntegrationWarning
 |      builtins.UserWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.UserWarning:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.integrate.quadpack.IntegrationWarning,integrate.quadpack,IntegrationWarning,"Python Library Documentation: class IntegrationWarning in module scipy.integrate.quadpack

class IntegrationWarning(builtins.UserWarning)
 |  Warning on issues during integration.
 |  
 |  Method resolution order:
 |      IntegrationWarning
 |      builtins.UserWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.UserWarning:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.integrate.quadpack._NQuad,integrate.quadpack,_NQuad,"Python Library Documentation: class _NQuad in module scipy.integrate.quadpack

class _NQuad(builtins.object)
 |  Methods defined here:
 |  
 |  __init__(self, func, ranges, opts, full_output)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  integrate(self, *args, **kwargs)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, func, ranges, opts, full_output)',)",scipy,1.1.0,scipy.integrate.quadpack._NQuad,integrate.quadpack,_NQuad,"Python Library Documentation: class _NQuad in module scipy.integrate.quadpack

class _NQuad(builtins.object)
 |  Methods defined here:
 |  
 |  __init__(self, func, ranges, opts, full_output)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  integrate(self, *args, **kwargs)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'func', 'ranges', 'opts', 'full_output')","(nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, func, ranges, opts, full_output)',)"
scipy,1.1.0,scipy.integrate.quadpack._OptFunc,integrate.quadpack,_OptFunc,"Python Library Documentation: class _OptFunc in module scipy.integrate.quadpack

class _OptFunc(builtins.object)
 |  Methods defined here:
 |  
 |  __call__(self, *args)
 |      Return stored dict.
 |  
 |  __init__(self, opt)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, opt)',)",scipy,1.1.0,scipy.integrate.quadpack._OptFunc,integrate.quadpack,_OptFunc,"Python Library Documentation: class _OptFunc in module scipy.integrate.quadpack

class _OptFunc(builtins.object)
 |  Methods defined here:
 |  
 |  __call__(self, *args)
 |      Return stored dict.
 |  
 |  __init__(self, opt)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'opt')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(self, opt)',)"
scipy,1.1.0,scipy.integrate.quadpack._RangeFunc,integrate.quadpack,_RangeFunc,"Python Library Documentation: class _RangeFunc in module scipy.integrate.quadpack

class _RangeFunc(builtins.object)
 |  Methods defined here:
 |  
 |  __call__(self, *args)
 |      Return stored value.
 |      
 |      *args needed because range_ can be float or func, and is called with
 |      variable number of parameters.
 |  
 |  __init__(self, range_)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, range_)',)",scipy,1.1.0,scipy.integrate.quadpack._RangeFunc,integrate.quadpack,_RangeFunc,"Python Library Documentation: class _RangeFunc in module scipy.integrate.quadpack

class _RangeFunc(builtins.object)
 |  Methods defined here:
 |  
 |  __call__(self, *args)
 |      Return stored value.
 |      
 |      *args needed because range_ can be float or func, and is called with
 |      variable number of parameters.
 |  
 |  __init__(self, range_)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'range_')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(self, range_)',)"
scipy,1.1.0,scipy.integrate.quadpack._quad,integrate.quadpack,_quad,"Python Library Documentation: function _quad in module scipy.integrate.quadpack

_quad(func, a, b, args, full_output, epsabs, epsrel, limit, points)
",function,"('(func, a, b, args, full_output, epsabs, epsrel, limit, points)',)",scipy,1.1.0,scipy.integrate.quadpack._quad,integrate.quadpack,_quad,"Python Library Documentation: function _quad in module scipy.integrate.quadpack

_quad(func, a, b, args, full_output, epsabs, epsrel, limit, points)
",function,"('func', 'a', 'b', 'args', 'full_output', 'epsabs', 'epsrel', 'limit', 'points')","(nan, nan, nan, nan, nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(func, a, b, args, full_output, epsabs, epsrel, limit, points)',)"
scipy,1.1.0,scipy.integrate.quadpack._quad_weight,integrate.quadpack,_quad_weight,"Python Library Documentation: function _quad_weight in module scipy.integrate.quadpack

_quad_weight(func, a, b, args, full_output, epsabs, epsrel, limlst, limit, maxp1, weight, wvar, wopts)
",function,"('(func, a, b, args, full_output, epsabs, epsrel, limlst, limit, maxp1, weight, wvar, wopts)',)",scipy,1.1.0,scipy.integrate.quadpack._quad_weight,integrate.quadpack,_quad_weight,"Python Library Documentation: function _quad_weight in module scipy.integrate.quadpack

_quad_weight(func, a, b, args, full_output, epsabs, epsrel, limlst, limit, maxp1, weight, wvar, wopts)
",function,"('func', 'a', 'b', 'args', 'full_output', 'epsabs', 'epsrel', 'limlst', 'limit', 'maxp1', 'weight', 'wvar', 'wopts')","(nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(func, a, b, args, full_output, epsabs, epsrel, limlst, limit, maxp1, weight, wvar, wopts)',)"
scipy,1.1.0,scipy.integrate.quadpack.dblquad,integrate.quadpack,dblquad,"Python Library Documentation: function dblquad in module scipy.integrate.quadpack

dblquad(func, a, b, gfun, hfun, args=(), epsabs=1.49e-08, epsrel=1.49e-08)
    Compute a double integral.
    
    Return the double (definite) integral of ``func(y, x)`` from ``x = a..b``
    and ``y = gfun(x)..hfun(x)``.
    
    Parameters
    ----------
    func : callable
        A Python function or method of at least two variables: y must be the
        first argument and x the second argument.
    a, b : float
        The limits of integration in x: `a` < `b`
    gfun : callable or float
        The lower boundary curve in y which is a function taking a single
        floating point argument (x) and returning a floating point result
        or a float indicating a constant boundary curve.
    hfun : callable or float
        The upper boundary curve in y (same requirements as `gfun`).
    args : sequence, optional
        Extra arguments to pass to `func`.
    epsabs : float, optional
        Absolute tolerance passed directly to the inner 1-D quadrature
        integration. Default is 1.49e-8.
    epsrel : float, optional
        Relative tolerance of the inner 1-D integrals. Default is 1.49e-8.
    
    Returns
    -------
    y : float
        The resultant integral.
    abserr : float
        An estimate of the error.
    
    See also
    --------
    quad : single integral
    tplquad : triple integral
    nquad : N-dimensional integrals
    fixed_quad : fixed-order Gaussian quadrature
    quadrature : adaptive Gaussian quadrature
    odeint : ODE integrator
    ode : ODE integrator
    simps : integrator for sampled data
    romb : integrator for sampled data
    scipy.special : for coefficients and roots of orthogonal polynomials
    
    Examples
    --------
    
    Compute the double integral of ``x * y**2`` over the box
    ``x`` ranging from 0 to 2 and ``y`` ranging from 0 to 1.
    
    >>> from scipy import integrate
    >>> f = lambda y, x: x*y**2
    >>> integrate.dblquad(f, 0, 2, lambda x: 0, lambda x: 1)
        (0.6666666666666667, 7.401486830834377e-15)
",function,"('(func, a, b, gfun, hfun, args=(), epsabs=1.49e-08, epsrel=1.49e-08)',)",scipy,1.1.0,scipy.integrate.quadpack.dblquad,integrate.quadpack,dblquad,"Python Library Documentation: function dblquad in module scipy.integrate.quadpack

dblquad(func, a, b, gfun, hfun, args=(), epsabs=1.49e-08, epsrel=1.49e-08)
    Compute a double integral.
    
    Return the double (definite) integral of ``func(y, x)`` from ``x = a..b``
    and ``y = gfun(x)..hfun(x)``.
    
    Parameters
    ----------
    func : callable
        A Python function or method of at least two variables: y must be the
        first argument and x the second argument.
    a, b : float
        The limits of integration in x: `a` < `b`
    gfun : callable or float
        The lower boundary curve in y which is a function taking a single
        floating point argument (x) and returning a floating point result
        or a float indicating a constant boundary curve.
    hfun : callable or float
        The upper boundary curve in y (same requirements as `gfun`).
    args : sequence, optional
        Extra arguments to pass to `func`.
    epsabs : float, optional
        Absolute tolerance passed directly to the inner 1-D quadrature
        integration. Default is 1.49e-8.
    epsrel : float, optional
        Relative tolerance of the inner 1-D integrals. Default is 1.49e-8.
    
    Returns
    -------
    y : float
        The resultant integral.
    abserr : float
        An estimate of the error.
    
    See also
    --------
    quad : single integral
    tplquad : triple integral
    nquad : N-dimensional integrals
    fixed_quad : fixed-order Gaussian quadrature
    quadrature : adaptive Gaussian quadrature
    odeint : ODE integrator
    ode : ODE integrator
    simps : integrator for sampled data
    romb : integrator for sampled data
    scipy.special : for coefficients and roots of orthogonal polynomials
    
    Examples
    --------
    
    Compute the double integral of ``x * y**2`` over the box
    ``x`` ranging from 0 to 2 and ``y`` ranging from 0 to 1.
    
    >>> from scipy import integrate
    >>> f = lambda y, x: x*y**2
    >>> integrate.dblquad(f, 0, 2, lambda x: 0, lambda x: 1)
        (0.6666666666666667, 7.401486830834377e-15)
",function,"('func', 'a', 'b', 'gfun', 'hfun', 'args', 'epsabs', 'epsrel')","(nan, nan, nan, nan, nan, (), 1.49e-08, 1.49e-08)","(nan, nan, nan, nan, nan, 'tuple', 'float', 'float')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(func, a, b, gfun, hfun, args=(), epsabs=1.49e-08, epsrel=1.49e-08)',)"
scipy,1.1.0,scipy.integrate.quadpack.error,integrate.quadpack,error,"Python Library Documentation: class error

class error(builtins.Exception)
 |  Common base class for all non-exit exceptions.
 |  
 |  Method resolution order:
 |      error
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.integrate.quadpack.error,integrate.quadpack,error,"Python Library Documentation: class error

class error(builtins.Exception)
 |  Common base class for all non-exit exceptions.
 |  
 |  Method resolution order:
 |      error
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.integrate.quadpack.nquad,integrate.quadpack,nquad,"Python Library Documentation: function nquad in module scipy.integrate.quadpack

nquad(func, ranges, args=None, opts=None, full_output=False)
    Integration over multiple variables.
    
    Wraps `quad` to enable integration over multiple variables.
    Various options allow improved integration of discontinuous functions, as
    well as the use of weighted integration, and generally finer control of the
    integration process.
    
    Parameters
    ----------
    func : {callable, scipy.LowLevelCallable}
        The function to be integrated. Has arguments of ``x0, ... xn``,
        ``t0, tm``, where integration is carried out over ``x0, ... xn``, which
        must be floats.  Function signature should be
        ``func(x0, x1, ..., xn, t0, t1, ..., tm)``.  Integration is carried out
        in order.  That is, integration over ``x0`` is the innermost integral,
        and ``xn`` is the outermost.
    
        If the user desires improved integration performance, then `f` may
        be a `scipy.LowLevelCallable` with one of the signatures::
    
            double func(int n, double *xx)
            double func(int n, double *xx, void *user_data)
    
        where ``n`` is the number of extra parameters and args is an array
        of doubles of the additional parameters, the ``xx`` array contains the
        coordinates. The ``user_data`` is the data contained in the
        `scipy.LowLevelCallable`.
    ranges : iterable object
        Each element of ranges may be either a sequence  of 2 numbers, or else
        a callable that returns such a sequence.  ``ranges[0]`` corresponds to
        integration over x0, and so on.  If an element of ranges is a callable,
        then it will be called with all of the integration arguments available,
        as well as any parametric arguments. e.g. if
        ``func = f(x0, x1, x2, t0, t1)``, then ``ranges[0]`` may be defined as
        either ``(a, b)`` or else as ``(a, b) = range0(x1, x2, t0, t1)``.
    args : iterable object, optional
        Additional arguments ``t0, ..., tn``, required by `func`, `ranges`, and
        ``opts``.
    opts : iterable object or dict, optional
        Options to be passed to `quad`.  May be empty, a dict, or
        a sequence of dicts or functions that return a dict.  If empty, the
        default options from scipy.integrate.quad are used.  If a dict, the same
        options are used for all levels of integraion.  If a sequence, then each
        element of the sequence corresponds to a particular integration. e.g.
        opts[0] corresponds to integration over x0, and so on. If a callable,
        the signature must be the same as for ``ranges``. The available
        options together with their default values are:
    
          - epsabs = 1.49e-08
          - epsrel = 1.49e-08
          - limit  = 50
          - points = None
          - weight = None
          - wvar   = None
          - wopts  = None
    
        For more information on these options, see `quad` and `quad_explain`.
    
    full_output : bool, optional
        Partial implementation of ``full_output`` from scipy.integrate.quad.
        The number of integrand function evaluations ``neval`` can be obtained
        by setting ``full_output=True`` when calling nquad.
    
    Returns
    -------
    result : float
        The result of the integration.
    abserr : float
        The maximum of the estimates of the absolute error in the various
        integration results.
    out_dict : dict, optional
        A dict containing additional information on the integration.
    
    See Also
    --------
    quad : 1-dimensional numerical integration
    dblquad, tplquad : double and triple integrals
    fixed_quad : fixed-order Gaussian quadrature
    quadrature : adaptive Gaussian quadrature
    
    Examples
    --------
    >>> from scipy import integrate
    >>> func = lambda x0,x1,x2,x3 : x0**2 + x1*x2 - x3**3 + np.sin(x0) + (
    ...                                 1 if (x0-.2*x3-.5-.25*x1>0) else 0)
    >>> points = [[lambda x1,x2,x3 : 0.2*x3 + 0.5 + 0.25*x1], [], [], []]
    >>> def opts0(*args, **kwargs):
    ...     return {'points':[0.2*args[2] + 0.5 + 0.25*args[0]]}
    >>> integrate.nquad(func, [[0,1], [-1,1], [.13,.8], [-.15,1]],
    ...                 opts=[opts0,{},{},{}], full_output=True)
    (1.5267454070738633, 2.9437360001402324e-14, {'neval': 388962})
    
    >>> scale = .1
    >>> def func2(x0, x1, x2, x3, t0, t1):
    ...     return x0*x1*x3**2 + np.sin(x2) + 1 + (1 if x0+t1*x1-t0>0 else 0)
    >>> def lim0(x1, x2, x3, t0, t1):
    ...     return [scale * (x1**2 + x2 + np.cos(x3)*t0*t1 + 1) - 1,
    ...             scale * (x1**2 + x2 + np.cos(x3)*t0*t1 + 1) + 1]
    >>> def lim1(x2, x3, t0, t1):
    ...     return [scale * (t0*x2 + t1*x3) - 1,
    ...             scale * (t0*x2 + t1*x3) + 1]
    >>> def lim2(x3, t0, t1):
    ...     return [scale * (x3 + t0**2*t1**3) - 1,
    ...             scale * (x3 + t0**2*t1**3) + 1]
    >>> def lim3(t0, t1):
    ...     return [scale * (t0+t1) - 1, scale * (t0+t1) + 1]
    >>> def opts0(x1, x2, x3, t0, t1):
    ...     return {'points' : [t0 - t1*x1]}
    >>> def opts1(x2, x3, t0, t1):
    ...     return {}
    >>> def opts2(x3, t0, t1):
    ...     return {}
    >>> def opts3(t0, t1):
    ...     return {}
    >>> integrate.nquad(func2, [lim0, lim1, lim2, lim3], args=(0,0),
    ...                 opts=[opts0, opts1, opts2, opts3])
    (25.066666666666666, 2.7829590483937256e-13)
",function,"('(func, ranges, args=None, opts=None, full_output=False)',)",scipy,1.1.0,scipy.integrate.quadpack.nquad,integrate.quadpack,nquad,"Python Library Documentation: function nquad in module scipy.integrate.quadpack

nquad(func, ranges, args=None, opts=None, full_output=False)
    Integration over multiple variables.
    
    Wraps `quad` to enable integration over multiple variables.
    Various options allow improved integration of discontinuous functions, as
    well as the use of weighted integration, and generally finer control of the
    integration process.
    
    Parameters
    ----------
    func : {callable, scipy.LowLevelCallable}
        The function to be integrated. Has arguments of ``x0, ... xn``,
        ``t0, tm``, where integration is carried out over ``x0, ... xn``, which
        must be floats.  Function signature should be
        ``func(x0, x1, ..., xn, t0, t1, ..., tm)``.  Integration is carried out
        in order.  That is, integration over ``x0`` is the innermost integral,
        and ``xn`` is the outermost.
    
        If the user desires improved integration performance, then `f` may
        be a `scipy.LowLevelCallable` with one of the signatures::
    
            double func(int n, double *xx)
            double func(int n, double *xx, void *user_data)
    
        where ``n`` is the number of extra parameters and args is an array
        of doubles of the additional parameters, the ``xx`` array contains the
        coordinates. The ``user_data`` is the data contained in the
        `scipy.LowLevelCallable`.
    ranges : iterable object
        Each element of ranges may be either a sequence  of 2 numbers, or else
        a callable that returns such a sequence.  ``ranges[0]`` corresponds to
        integration over x0, and so on.  If an element of ranges is a callable,
        then it will be called with all of the integration arguments available,
        as well as any parametric arguments. e.g. if
        ``func = f(x0, x1, x2, t0, t1)``, then ``ranges[0]`` may be defined as
        either ``(a, b)`` or else as ``(a, b) = range0(x1, x2, t0, t1)``.
    args : iterable object, optional
        Additional arguments ``t0, ..., tn``, required by `func`, `ranges`, and
        ``opts``.
    opts : iterable object or dict, optional
        Options to be passed to `quad`.  May be empty, a dict, or
        a sequence of dicts or functions that return a dict.  If empty, the
        default options from scipy.integrate.quad are used.  If a dict, the same
        options are used for all levels of integraion.  If a sequence, then each
        element of the sequence corresponds to a particular integration. e.g.
        opts[0] corresponds to integration over x0, and so on. If a callable,
        the signature must be the same as for ``ranges``. The available
        options together with their default values are:
    
          - epsabs = 1.49e-08
          - epsrel = 1.49e-08
          - limit  = 50
          - points = None
          - weight = None
          - wvar   = None
          - wopts  = None
    
        For more information on these options, see `quad` and `quad_explain`.
    
    full_output : bool, optional
        Partial implementation of ``full_output`` from scipy.integrate.quad.
        The number of integrand function evaluations ``neval`` can be obtained
        by setting ``full_output=True`` when calling nquad.
    
    Returns
    -------
    result : float
        The result of the integration.
    abserr : float
        The maximum of the estimates of the absolute error in the various
        integration results.
    out_dict : dict, optional
        A dict containing additional information on the integration.
    
    See Also
    --------
    quad : 1-dimensional numerical integration
    dblquad, tplquad : double and triple integrals
    fixed_quad : fixed-order Gaussian quadrature
    quadrature : adaptive Gaussian quadrature
    
    Examples
    --------
    >>> from scipy import integrate
    >>> func = lambda x0,x1,x2,x3 : x0**2 + x1*x2 - x3**3 + np.sin(x0) + (
    ...                                 1 if (x0-.2*x3-.5-.25*x1>0) else 0)
    >>> points = [[lambda x1,x2,x3 : 0.2*x3 + 0.5 + 0.25*x1], [], [], []]
    >>> def opts0(*args, **kwargs):
    ...     return {'points':[0.2*args[2] + 0.5 + 0.25*args[0]]}
    >>> integrate.nquad(func, [[0,1], [-1,1], [.13,.8], [-.15,1]],
    ...                 opts=[opts0,{},{},{}], full_output=True)
    (1.5267454070738633, 2.9437360001402324e-14, {'neval': 388962})
    
    >>> scale = .1
    >>> def func2(x0, x1, x2, x3, t0, t1):
    ...     return x0*x1*x3**2 + np.sin(x2) + 1 + (1 if x0+t1*x1-t0>0 else 0)
    >>> def lim0(x1, x2, x3, t0, t1):
    ...     return [scale * (x1**2 + x2 + np.cos(x3)*t0*t1 + 1) - 1,
    ...             scale * (x1**2 + x2 + np.cos(x3)*t0*t1 + 1) + 1]
    >>> def lim1(x2, x3, t0, t1):
    ...     return [scale * (t0*x2 + t1*x3) - 1,
    ...             scale * (t0*x2 + t1*x3) + 1]
    >>> def lim2(x3, t0, t1):
    ...     return [scale * (x3 + t0**2*t1**3) - 1,
    ...             scale * (x3 + t0**2*t1**3) + 1]
    >>> def lim3(t0, t1):
    ...     return [scale * (t0+t1) - 1, scale * (t0+t1) + 1]
    >>> def opts0(x1, x2, x3, t0, t1):
    ...     return {'points' : [t0 - t1*x1]}
    >>> def opts1(x2, x3, t0, t1):
    ...     return {}
    >>> def opts2(x3, t0, t1):
    ...     return {}
    >>> def opts3(t0, t1):
    ...     return {}
    >>> integrate.nquad(func2, [lim0, lim1, lim2, lim3], args=(0,0),
    ...                 opts=[opts0, opts1, opts2, opts3])
    (25.066666666666666, 2.7829590483937256e-13)
",function,"('func', 'ranges', 'args', 'opts', 'full_output')","(nan, nan, None, None, False)","(nan, nan, 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(func, ranges, args=None, opts=None, full_output=False)',)"
scipy,1.1.0,scipy.integrate.quadpack.partial,integrate.quadpack,partial,"Python Library Documentation: class partial in module functools

class partial(builtins.object)
 |  partial(func, *args, **keywords) - new function with partial application
 |  of the given arguments and keywords.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, /, *args, **kwargs)
 |      Call self as a function.
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |  
 |  args
 |      tuple of arguments to future partial calls
 |  
 |  func
 |      function object to use in future partial calls
 |  
 |  keywords
 |      dictionary of keyword arguments to future partial calls
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.integrate.quadpack.partial,integrate.quadpack,partial,"Python Library Documentation: class partial in module functools

class partial(builtins.object)
 |  partial(func, *args, **keywords) - new function with partial application
 |  of the given arguments and keywords.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, /, *args, **kwargs)
 |      Call self as a function.
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |  
 |  args
 |      tuple of arguments to future partial calls
 |  
 |  func
 |      function object to use in future partial calls
 |  
 |  keywords
 |      dictionary of keyword arguments to future partial calls
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.integrate.quadpack.quad,integrate.quadpack,quad,"Python Library Documentation: function quad in module scipy.integrate.quadpack

quad(func, a, b, args=(), full_output=0, epsabs=1.49e-08, epsrel=1.49e-08, limit=50, points=None, weight=None, wvar=None, wopts=None, maxp1=50, limlst=50)
    Compute a definite integral.
    
    Integrate func from `a` to `b` (possibly infinite interval) using a
    technique from the Fortran library QUADPACK.
    
    Parameters
    ----------
    func : {function, scipy.LowLevelCallable}
        A Python function or method to integrate.  If `func` takes many
        arguments, it is integrated along the axis corresponding to the
        first argument.
    
        If the user desires improved integration performance, then `f` may
        be a `scipy.LowLevelCallable` with one of the signatures::
    
            double func(double x)
            double func(double x, void *user_data)
            double func(int n, double *xx)
            double func(int n, double *xx, void *user_data)
    
        The ``user_data`` is the data contained in the `scipy.LowLevelCallable`.
        In the call forms with ``xx``,  ``n`` is the length of the ``xx``
        array which contains ``xx[0] == x`` and the rest of the items are
        numbers contained in the ``args`` argument of quad.
    
        In addition, certain ctypes call signatures are supported for
        backward compatibility, but those should not be used in new code.
    a : float
        Lower limit of integration (use -numpy.inf for -infinity).
    b : float
        Upper limit of integration (use numpy.inf for +infinity).
    args : tuple, optional
        Extra arguments to pass to `func`.
    full_output : int, optional
        Non-zero to return a dictionary of integration information.
        If non-zero, warning messages are also suppressed and the
        message is appended to the output tuple.
    
    Returns
    -------
    y : float
        The integral of func from `a` to `b`.
    abserr : float
        An estimate of the absolute error in the result.
    infodict : dict
        A dictionary containing additional information.
        Run scipy.integrate.quad_explain() for more information.
    message
        A convergence message.
    explain
        Appended only with 'cos' or 'sin' weighting and infinite
        integration limits, it contains an explanation of the codes in
        infodict['ierlst']
    
    Other Parameters
    ----------------
    epsabs : float or int, optional
        Absolute error tolerance.
    epsrel : float or int, optional
        Relative error tolerance.
    limit : float or int, optional
        An upper bound on the number of subintervals used in the adaptive
        algorithm.
    points : (sequence of floats,ints), optional
        A sequence of break points in the bounded integration interval
        where local difficulties of the integrand may occur (e.g.,
        singularities, discontinuities). The sequence does not have
        to be sorted.
    weight : float or int, optional
        String indicating weighting function. Full explanation for this
        and the remaining arguments can be found below.
    wvar : optional
        Variables for use with weighting functions.
    wopts : optional
        Optional input for reusing Chebyshev moments.
    maxp1 : float or int, optional
        An upper bound on the number of Chebyshev moments.
    limlst : int, optional
        Upper bound on the number of cycles (>=3) for use with a sinusoidal
        weighting and an infinite end-point.
    
    See Also
    --------
    dblquad : double integral
    tplquad : triple integral
    nquad : n-dimensional integrals (uses `quad` recursively)
    fixed_quad : fixed-order Gaussian quadrature
    quadrature : adaptive Gaussian quadrature
    odeint : ODE integrator
    ode : ODE integrator
    simps : integrator for sampled data
    romb : integrator for sampled data
    scipy.special : for coefficients and roots of orthogonal polynomials
    
    Notes
    -----
    
    **Extra information for quad() inputs and outputs**
    
    If full_output is non-zero, then the third output argument
    (infodict) is a dictionary with entries as tabulated below.  For
    infinite limits, the range is transformed to (0,1) and the
    optional outputs are given with respect to this transformed range.
    Let M be the input argument limit and let K be infodict['last'].
    The entries are:
    
    'neval'
        The number of function evaluations.
    'last'
        The number, K, of subintervals produced in the subdivision process.
    'alist'
        A rank-1 array of length M, the first K elements of which are the
        left end points of the subintervals in the partition of the
        integration range.
    'blist'
        A rank-1 array of length M, the first K elements of which are the
        right end points of the subintervals.
    'rlist'
        A rank-1 array of length M, the first K elements of which are the
        integral approximations on the subintervals.
    'elist'
        A rank-1 array of length M, the first K elements of which are the
        moduli of the absolute error estimates on the subintervals.
    'iord'
        A rank-1 integer array of length M, the first L elements of
        which are pointers to the error estimates over the subintervals
        with ``L=K`` if ``K<=M/2+2`` or ``L=M+1-K`` otherwise. Let I be the
        sequence ``infodict['iord']`` and let E be the sequence
        ``infodict['elist']``.  Then ``E[I[1]], ..., E[I[L]]`` forms a
        decreasing sequence.
    
    If the input argument points is provided (i.e. it is not None),
    the following additional outputs are placed in the output
    dictionary.  Assume the points sequence is of length P.
    
    'pts'
        A rank-1 array of length P+2 containing the integration limits
        and the break points of the intervals in ascending order.
        This is an array giving the subintervals over which integration
        will occur.
    'level'
        A rank-1 integer array of length M (=limit), containing the
        subdivision levels of the subintervals, i.e., if (aa,bb) is a
        subinterval of ``(pts[1], pts[2])`` where ``pts[0]`` and ``pts[2]``
        are adjacent elements of ``infodict['pts']``, then (aa,bb) has level l
        if ``|bb-aa| = |pts[2]-pts[1]| * 2**(-l)``.
    'ndin'
        A rank-1 integer array of length P+2.  After the first integration
        over the intervals (pts[1], pts[2]), the error estimates over some
        of the intervals may have been increased artificially in order to
        put their subdivision forward.  This array has ones in slots
        corresponding to the subintervals for which this happens.
    
    **Weighting the integrand**
    
    The input variables, *weight* and *wvar*, are used to weight the
    integrand by a select list of functions.  Different integration
    methods are used to compute the integral with these weighting
    functions.  The possible values of weight and the corresponding
    weighting functions are.
    
    ==========  ===================================   =====================
    ``weight``  Weight function used                  ``wvar``
    ==========  ===================================   =====================
    'cos'       cos(w*x)                              wvar = w
    'sin'       sin(w*x)                              wvar = w
    'alg'       g(x) = ((x-a)**alpha)*((b-x)**beta)   wvar = (alpha, beta)
    'alg-loga'  g(x)*log(x-a)                         wvar = (alpha, beta)
    'alg-logb'  g(x)*log(b-x)                         wvar = (alpha, beta)
    'alg-log'   g(x)*log(x-a)*log(b-x)                wvar = (alpha, beta)
    'cauchy'    1/(x-c)                               wvar = c
    ==========  ===================================   =====================
    
    wvar holds the parameter w, (alpha, beta), or c depending on the weight
    selected.  In these expressions, a and b are the integration limits.
    
    For the 'cos' and 'sin' weighting, additional inputs and outputs are
    available.
    
    For finite integration limits, the integration is performed using a
    Clenshaw-Curtis method which uses Chebyshev moments.  For repeated
    calculations, these moments are saved in the output dictionary:
    
    'momcom'
        The maximum level of Chebyshev moments that have been computed,
        i.e., if ``M_c`` is ``infodict['momcom']`` then the moments have been
        computed for intervals of length ``|b-a| * 2**(-l)``,
        ``l=0,1,...,M_c``.
    'nnlog'
        A rank-1 integer array of length M(=limit), containing the
        subdivision levels of the subintervals, i.e., an element of this
        array is equal to l if the corresponding subinterval is
        ``|b-a|* 2**(-l)``.
    'chebmo'
        A rank-2 array of shape (25, maxp1) containing the computed
        Chebyshev moments.  These can be passed on to an integration
        over the same interval by passing this array as the second
        element of the sequence wopts and passing infodict['momcom'] as
        the first element.
    
    If one of the integration limits is infinite, then a Fourier integral is
    computed (assuming w neq 0).  If full_output is 1 and a numerical error
    is encountered, besides the error message attached to the output tuple,
    a dictionary is also appended to the output tuple which translates the
    error codes in the array ``info['ierlst']`` to English messages.  The
    output information dictionary contains the following entries instead of
    'last', 'alist', 'blist', 'rlist', and 'elist':
    
    'lst'
        The number of subintervals needed for the integration (call it ``K_f``).
    'rslst'
        A rank-1 array of length M_f=limlst, whose first ``K_f`` elements
        contain the integral contribution over the interval
        ``(a+(k-1)c, a+kc)`` where ``c = (2*floor(|w|) + 1) * pi / |w|``
        and ``k=1,2,...,K_f``.
    'erlst'
        A rank-1 array of length ``M_f`` containing the error estimate
        corresponding to the interval in the same position in
        ``infodict['rslist']``.
    'ierlst'
        A rank-1 integer array of length ``M_f`` containing an error flag
        corresponding to the interval in the same position in
        ``infodict['rslist']``.  See the explanation dictionary (last entry
        in the output tuple) for the meaning of the codes.
    
    Examples
    --------
    Calculate :math:`\int^4_0 x^2 dx` and compare with an analytic result
    
    >>> from scipy import integrate
    >>> x2 = lambda x: x**2
    >>> integrate.quad(x2, 0, 4)
    (21.333333333333332, 2.3684757858670003e-13)
    >>> print(4**3 / 3.)  # analytical result
    21.3333333333
    
    Calculate :math:`\int^\infty_0 e^{-x} dx`
    
    >>> invexp = lambda x: np.exp(-x)
    >>> integrate.quad(invexp, 0, np.inf)
    (1.0, 5.842605999138044e-11)
    
    >>> f = lambda x,a : a*x
    >>> y, err = integrate.quad(f, 0, 1, args=(1,))
    >>> y
    0.5
    >>> y, err = integrate.quad(f, 0, 1, args=(3,))
    >>> y
    1.5
    
    Calculate :math:`\int^1_0 x^2 + y^2 dx` with ctypes, holding
    y parameter as 1::
    
        testlib.c =>
            double func(int n, double args[n]){
                return args[0]*args[0] + args[1]*args[1];}
        compile to library testlib.*
    
    ::
    
       from scipy import integrate
       import ctypes
       lib = ctypes.CDLL('/home/.../testlib.*') #use absolute path
       lib.func.restype = ctypes.c_double
       lib.func.argtypes = (ctypes.c_int,ctypes.c_double)
       integrate.quad(lib.func,0,1,(1))
       #(1.3333333333333333, 1.4802973661668752e-14)
       print((1.0**3/3.0 + 1.0) - (0.0**3/3.0 + 0.0)) #Analytic result
       # 1.3333333333333333
    
    Be aware that pulse shapes and other sharp features as compared to the
    size of the integration interval may not be integrated correctly using
    this method. A simplified example of this limitation is integrating a
    y-axis reflected step function with many zero values within the integrals
    bounds.
    
    >>> y = lambda x: 1 if x<=0 else 0
    >>> integrate.quad(y, -1, 1)
    (1.0, 1.1102230246251565e-14)
    >>> integrate.quad(y, -1, 100)
    (1.0000000002199108, 1.0189464580163188e-08)
    >>> integrate.quad(y, -1, 10000)
    (0.0, 0.0)
",function,"('(func, a, b, args=(), full_output=0, epsabs=1.49e-08, epsrel=1.49e-08, limit=50, points=None, weight=None, wvar=None, wopts=None, maxp1=50, limlst=50)',)",scipy,1.1.0,scipy.integrate.quadpack.quad,integrate.quadpack,quad,"Python Library Documentation: function quad in module scipy.integrate.quadpack

quad(func, a, b, args=(), full_output=0, epsabs=1.49e-08, epsrel=1.49e-08, limit=50, points=None, weight=None, wvar=None, wopts=None, maxp1=50, limlst=50)
    Compute a definite integral.
    
    Integrate func from `a` to `b` (possibly infinite interval) using a
    technique from the Fortran library QUADPACK.
    
    Parameters
    ----------
    func : {function, scipy.LowLevelCallable}
        A Python function or method to integrate.  If `func` takes many
        arguments, it is integrated along the axis corresponding to the
        first argument.
    
        If the user desires improved integration performance, then `f` may
        be a `scipy.LowLevelCallable` with one of the signatures::
    
            double func(double x)
            double func(double x, void *user_data)
            double func(int n, double *xx)
            double func(int n, double *xx, void *user_data)
    
        The ``user_data`` is the data contained in the `scipy.LowLevelCallable`.
        In the call forms with ``xx``,  ``n`` is the length of the ``xx``
        array which contains ``xx[0] == x`` and the rest of the items are
        numbers contained in the ``args`` argument of quad.
    
        In addition, certain ctypes call signatures are supported for
        backward compatibility, but those should not be used in new code.
    a : float
        Lower limit of integration (use -numpy.inf for -infinity).
    b : float
        Upper limit of integration (use numpy.inf for +infinity).
    args : tuple, optional
        Extra arguments to pass to `func`.
    full_output : int, optional
        Non-zero to return a dictionary of integration information.
        If non-zero, warning messages are also suppressed and the
        message is appended to the output tuple.
    
    Returns
    -------
    y : float
        The integral of func from `a` to `b`.
    abserr : float
        An estimate of the absolute error in the result.
    infodict : dict
        A dictionary containing additional information.
        Run scipy.integrate.quad_explain() for more information.
    message
        A convergence message.
    explain
        Appended only with 'cos' or 'sin' weighting and infinite
        integration limits, it contains an explanation of the codes in
        infodict['ierlst']
    
    Other Parameters
    ----------------
    epsabs : float or int, optional
        Absolute error tolerance.
    epsrel : float or int, optional
        Relative error tolerance.
    limit : float or int, optional
        An upper bound on the number of subintervals used in the adaptive
        algorithm.
    points : (sequence of floats,ints), optional
        A sequence of break points in the bounded integration interval
        where local difficulties of the integrand may occur (e.g.,
        singularities, discontinuities). The sequence does not have
        to be sorted.
    weight : float or int, optional
        String indicating weighting function. Full explanation for this
        and the remaining arguments can be found below.
    wvar : optional
        Variables for use with weighting functions.
    wopts : optional
        Optional input for reusing Chebyshev moments.
    maxp1 : float or int, optional
        An upper bound on the number of Chebyshev moments.
    limlst : int, optional
        Upper bound on the number of cycles (>=3) for use with a sinusoidal
        weighting and an infinite end-point.
    
    See Also
    --------
    dblquad : double integral
    tplquad : triple integral
    nquad : n-dimensional integrals (uses `quad` recursively)
    fixed_quad : fixed-order Gaussian quadrature
    quadrature : adaptive Gaussian quadrature
    odeint : ODE integrator
    ode : ODE integrator
    simps : integrator for sampled data
    romb : integrator for sampled data
    scipy.special : for coefficients and roots of orthogonal polynomials
    
    Notes
    -----
    
    **Extra information for quad() inputs and outputs**
    
    If full_output is non-zero, then the third output argument
    (infodict) is a dictionary with entries as tabulated below.  For
    infinite limits, the range is transformed to (0,1) and the
    optional outputs are given with respect to this transformed range.
    Let M be the input argument limit and let K be infodict['last'].
    The entries are:
    
    'neval'
        The number of function evaluations.
    'last'
        The number, K, of subintervals produced in the subdivision process.
    'alist'
        A rank-1 array of length M, the first K elements of which are the
        left end points of the subintervals in the partition of the
        integration range.
    'blist'
        A rank-1 array of length M, the first K elements of which are the
        right end points of the subintervals.
    'rlist'
        A rank-1 array of length M, the first K elements of which are the
        integral approximations on the subintervals.
    'elist'
        A rank-1 array of length M, the first K elements of which are the
        moduli of the absolute error estimates on the subintervals.
    'iord'
        A rank-1 integer array of length M, the first L elements of
        which are pointers to the error estimates over the subintervals
        with ``L=K`` if ``K<=M/2+2`` or ``L=M+1-K`` otherwise. Let I be the
        sequence ``infodict['iord']`` and let E be the sequence
        ``infodict['elist']``.  Then ``E[I[1]], ..., E[I[L]]`` forms a
        decreasing sequence.
    
    If the input argument points is provided (i.e. it is not None),
    the following additional outputs are placed in the output
    dictionary.  Assume the points sequence is of length P.
    
    'pts'
        A rank-1 array of length P+2 containing the integration limits
        and the break points of the intervals in ascending order.
        This is an array giving the subintervals over which integration
        will occur.
    'level'
        A rank-1 integer array of length M (=limit), containing the
        subdivision levels of the subintervals, i.e., if (aa,bb) is a
        subinterval of ``(pts[1], pts[2])`` where ``pts[0]`` and ``pts[2]``
        are adjacent elements of ``infodict['pts']``, then (aa,bb) has level l
        if ``|bb-aa| = |pts[2]-pts[1]| * 2**(-l)``.
    'ndin'
        A rank-1 integer array of length P+2.  After the first integration
        over the intervals (pts[1], pts[2]), the error estimates over some
        of the intervals may have been increased artificially in order to
        put their subdivision forward.  This array has ones in slots
        corresponding to the subintervals for which this happens.
    
    **Weighting the integrand**
    
    The input variables, *weight* and *wvar*, are used to weight the
    integrand by a select list of functions.  Different integration
    methods are used to compute the integral with these weighting
    functions.  The possible values of weight and the corresponding
    weighting functions are.
    
    ==========  ===================================   =====================
    ``weight``  Weight function used                  ``wvar``
    ==========  ===================================   =====================
    'cos'       cos(w*x)                              wvar = w
    'sin'       sin(w*x)                              wvar = w
    'alg'       g(x) = ((x-a)**alpha)*((b-x)**beta)   wvar = (alpha, beta)
    'alg-loga'  g(x)*log(x-a)                         wvar = (alpha, beta)
    'alg-logb'  g(x)*log(b-x)                         wvar = (alpha, beta)
    'alg-log'   g(x)*log(x-a)*log(b-x)                wvar = (alpha, beta)
    'cauchy'    1/(x-c)                               wvar = c
    ==========  ===================================   =====================
    
    wvar holds the parameter w, (alpha, beta), or c depending on the weight
    selected.  In these expressions, a and b are the integration limits.
    
    For the 'cos' and 'sin' weighting, additional inputs and outputs are
    available.
    
    For finite integration limits, the integration is performed using a
    Clenshaw-Curtis method which uses Chebyshev moments.  For repeated
    calculations, these moments are saved in the output dictionary:
    
    'momcom'
        The maximum level of Chebyshev moments that have been computed,
        i.e., if ``M_c`` is ``infodict['momcom']`` then the moments have been
        computed for intervals of length ``|b-a| * 2**(-l)``,
        ``l=0,1,...,M_c``.
    'nnlog'
        A rank-1 integer array of length M(=limit), containing the
        subdivision levels of the subintervals, i.e., an element of this
        array is equal to l if the corresponding subinterval is
        ``|b-a|* 2**(-l)``.
    'chebmo'
        A rank-2 array of shape (25, maxp1) containing the computed
        Chebyshev moments.  These can be passed on to an integration
        over the same interval by passing this array as the second
        element of the sequence wopts and passing infodict['momcom'] as
        the first element.
    
    If one of the integration limits is infinite, then a Fourier integral is
    computed (assuming w neq 0).  If full_output is 1 and a numerical error
    is encountered, besides the error message attached to the output tuple,
    a dictionary is also appended to the output tuple which translates the
    error codes in the array ``info['ierlst']`` to English messages.  The
    output information dictionary contains the following entries instead of
    'last', 'alist', 'blist', 'rlist', and 'elist':
    
    'lst'
        The number of subintervals needed for the integration (call it ``K_f``).
    'rslst'
        A rank-1 array of length M_f=limlst, whose first ``K_f`` elements
        contain the integral contribution over the interval
        ``(a+(k-1)c, a+kc)`` where ``c = (2*floor(|w|) + 1) * pi / |w|``
        and ``k=1,2,...,K_f``.
    'erlst'
        A rank-1 array of length ``M_f`` containing the error estimate
        corresponding to the interval in the same position in
        ``infodict['rslist']``.
    'ierlst'
        A rank-1 integer array of length ``M_f`` containing an error flag
        corresponding to the interval in the same position in
        ``infodict['rslist']``.  See the explanation dictionary (last entry
        in the output tuple) for the meaning of the codes.
    
    Examples
    --------
    Calculate :math:`\int^4_0 x^2 dx` and compare with an analytic result
    
    >>> from scipy import integrate
    >>> x2 = lambda x: x**2
    >>> integrate.quad(x2, 0, 4)
    (21.333333333333332, 2.3684757858670003e-13)
    >>> print(4**3 / 3.)  # analytical result
    21.3333333333
    
    Calculate :math:`\int^\infty_0 e^{-x} dx`
    
    >>> invexp = lambda x: np.exp(-x)
    >>> integrate.quad(invexp, 0, np.inf)
    (1.0, 5.842605999138044e-11)
    
    >>> f = lambda x,a : a*x
    >>> y, err = integrate.quad(f, 0, 1, args=(1,))
    >>> y
    0.5
    >>> y, err = integrate.quad(f, 0, 1, args=(3,))
    >>> y
    1.5
    
    Calculate :math:`\int^1_0 x^2 + y^2 dx` with ctypes, holding
    y parameter as 1::
    
        testlib.c =>
            double func(int n, double args[n]){
                return args[0]*args[0] + args[1]*args[1];}
        compile to library testlib.*
    
    ::
    
       from scipy import integrate
       import ctypes
       lib = ctypes.CDLL('/home/.../testlib.*') #use absolute path
       lib.func.restype = ctypes.c_double
       lib.func.argtypes = (ctypes.c_int,ctypes.c_double)
       integrate.quad(lib.func,0,1,(1))
       #(1.3333333333333333, 1.4802973661668752e-14)
       print((1.0**3/3.0 + 1.0) - (0.0**3/3.0 + 0.0)) #Analytic result
       # 1.3333333333333333
    
    Be aware that pulse shapes and other sharp features as compared to the
    size of the integration interval may not be integrated correctly using
    this method. A simplified example of this limitation is integrating a
    y-axis reflected step function with many zero values within the integrals
    bounds.
    
    >>> y = lambda x: 1 if x<=0 else 0
    >>> integrate.quad(y, -1, 1)
    (1.0, 1.1102230246251565e-14)
    >>> integrate.quad(y, -1, 100)
    (1.0000000002199108, 1.0189464580163188e-08)
    >>> integrate.quad(y, -1, 10000)
    (0.0, 0.0)
",function,"('func', 'a', 'b', 'args', 'full_output', 'epsabs', 'epsrel', 'limit', 'points', 'weight', 'wvar', 'wopts', 'maxp1', 'limlst')","(nan, nan, nan, (), 0, 1.49e-08, 1.49e-08, 50, None, None, None, None, 50, 50)","(nan, nan, nan, 'tuple', 'int', 'float', 'float', 'int', 'NoneType', 'NoneType', 'NoneType', 'NoneType', 'int', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(func, a, b, args=(), full_output=0, epsabs=1.49e-08, epsrel=1.49e-08, limit=50, points=None, weight=None, wvar=None, wopts=None, maxp1=50, limlst=50)',)"
scipy,1.1.0,scipy.integrate.quadpack.quad_explain,integrate.quadpack,quad_explain,"Python Library Documentation: function quad_explain in module scipy.integrate.quadpack

quad_explain(output=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>)
    Print extra information about integrate.quad() parameters and returns.
    
    Parameters
    ----------
    output : instance with ""write"" method, optional
        Information about `quad` is passed to ``output.write()``.
        Default is ``sys.stdout``.
    
    Returns
    -------
    None
",function,"(""(output=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>)"",)",scipy,1.1.0,scipy.integrate.quadpack.quad_explain,integrate.quadpack,quad_explain,"Python Library Documentation: function quad_explain in module scipy.integrate.quadpack

quad_explain(output=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>)
    Print extra information about integrate.quad() parameters and returns.
    
    Parameters
    ----------
    output : instance with ""write"" method, optional
        Information about `quad` is passed to ``output.write()``.
        Default is ``sys.stdout``.
    
    Returns
    -------
    None
",function,"('output',)","(<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>,)","('TextIOWrapper',)","('arg_info',)","(""(output=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>)"",)"
scipy,1.1.0,scipy.integrate.quadpack.tplquad,integrate.quadpack,tplquad,"Python Library Documentation: function tplquad in module scipy.integrate.quadpack

tplquad(func, a, b, gfun, hfun, qfun, rfun, args=(), epsabs=1.49e-08, epsrel=1.49e-08)
    Compute a triple (definite) integral.
    
    Return the triple integral of ``func(z, y, x)`` from ``x = a..b``,
    ``y = gfun(x)..hfun(x)``, and ``z = qfun(x,y)..rfun(x,y)``.
    
    Parameters
    ----------
    func : function
        A Python function or method of at least three variables in the
        order (z, y, x).
    a, b : float
        The limits of integration in x: `a` < `b`
    gfun : function or float
        The lower boundary curve in y which is a function taking a single
        floating point argument (x) and returning a floating point result
        or a float indicating a constant boundary curve.
    hfun : function or float
        The upper boundary curve in y (same requirements as `gfun`).
    qfun : function or float
        The lower boundary surface in z.  It must be a function that takes
        two floats in the order (x, y) and returns a float or a float
        indicating a constant boundary surface.
    rfun : function or float
        The upper boundary surface in z. (Same requirements as `qfun`.)
    args : tuple, optional
        Extra arguments to pass to `func`.
    epsabs : float, optional
        Absolute tolerance passed directly to the innermost 1-D quadrature
        integration. Default is 1.49e-8.
    epsrel : float, optional
        Relative tolerance of the innermost 1-D integrals. Default is 1.49e-8.
    
    Returns
    -------
    y : float
        The resultant integral.
    abserr : float
        An estimate of the error.
    
    See Also
    --------
    quad: Adaptive quadrature using QUADPACK
    quadrature: Adaptive Gaussian quadrature
    fixed_quad: Fixed-order Gaussian quadrature
    dblquad: Double integrals
    nquad : N-dimensional integrals
    romb: Integrators for sampled data
    simps: Integrators for sampled data
    ode: ODE integrators
    odeint: ODE integrators
    scipy.special: For coefficients and roots of orthogonal polynomials
    
    Examples
    --------
    
    Compute the triple integral of ``x * y * z``, over ``x`` ranging 
    from 1 to 2, ``y`` ranging from 2 to 3, ``z`` ranging from 0 to 1.
    
    >>> from scipy import integrate
    >>> f = lambda z, y, x: x*y*z
    >>> integrate.tplquad(f, 1, 2, lambda x: 2, lambda x: 3,
    ...                   lambda x, y: 0, lambda x, y: 1)
    (1.8750000000000002, 3.324644794257407e-14)
",function,"('(func, a, b, gfun, hfun, qfun, rfun, args=(), epsabs=1.49e-08, epsrel=1.49e-08)',)",scipy,1.1.0,scipy.integrate.quadpack.tplquad,integrate.quadpack,tplquad,"Python Library Documentation: function tplquad in module scipy.integrate.quadpack

tplquad(func, a, b, gfun, hfun, qfun, rfun, args=(), epsabs=1.49e-08, epsrel=1.49e-08)
    Compute a triple (definite) integral.
    
    Return the triple integral of ``func(z, y, x)`` from ``x = a..b``,
    ``y = gfun(x)..hfun(x)``, and ``z = qfun(x,y)..rfun(x,y)``.
    
    Parameters
    ----------
    func : function
        A Python function or method of at least three variables in the
        order (z, y, x).
    a, b : float
        The limits of integration in x: `a` < `b`
    gfun : function or float
        The lower boundary curve in y which is a function taking a single
        floating point argument (x) and returning a floating point result
        or a float indicating a constant boundary curve.
    hfun : function or float
        The upper boundary curve in y (same requirements as `gfun`).
    qfun : function or float
        The lower boundary surface in z.  It must be a function that takes
        two floats in the order (x, y) and returns a float or a float
        indicating a constant boundary surface.
    rfun : function or float
        The upper boundary surface in z. (Same requirements as `qfun`.)
    args : tuple, optional
        Extra arguments to pass to `func`.
    epsabs : float, optional
        Absolute tolerance passed directly to the innermost 1-D quadrature
        integration. Default is 1.49e-8.
    epsrel : float, optional
        Relative tolerance of the innermost 1-D integrals. Default is 1.49e-8.
    
    Returns
    -------
    y : float
        The resultant integral.
    abserr : float
        An estimate of the error.
    
    See Also
    --------
    quad: Adaptive quadrature using QUADPACK
    quadrature: Adaptive Gaussian quadrature
    fixed_quad: Fixed-order Gaussian quadrature
    dblquad: Double integrals
    nquad : N-dimensional integrals
    romb: Integrators for sampled data
    simps: Integrators for sampled data
    ode: ODE integrators
    odeint: ODE integrators
    scipy.special: For coefficients and roots of orthogonal polynomials
    
    Examples
    --------
    
    Compute the triple integral of ``x * y * z``, over ``x`` ranging 
    from 1 to 2, ``y`` ranging from 2 to 3, ``z`` ranging from 0 to 1.
    
    >>> from scipy import integrate
    >>> f = lambda z, y, x: x*y*z
    >>> integrate.tplquad(f, 1, 2, lambda x: 2, lambda x: 3,
    ...                   lambda x, y: 0, lambda x, y: 1)
    (1.8750000000000002, 3.324644794257407e-14)
",function,"('func', 'a', 'b', 'gfun', 'hfun', 'qfun', 'rfun', 'args', 'epsabs', 'epsrel')","(nan, nan, nan, nan, nan, nan, nan, (), 1.49e-08, 1.49e-08)","(nan, nan, nan, nan, nan, nan, nan, 'tuple', 'float', 'float')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(func, a, b, gfun, hfun, qfun, rfun, args=(), epsabs=1.49e-08, epsrel=1.49e-08)',)"
scipy,1.1.0,scipy.integrate.quadrature.__class__,integrate.quadrature,function,"Python Library Documentation: class function in module builtins

class function(object)
 |  function(code, globals[, name[, argdefs[, closure]]])
 |  
 |  Create a function object from a code object and a dictionary.
 |  The optional name string overrides the name from the code object.
 |  The optional argdefs tuple specifies the default argument values.
 |  The optional closure tuple supplies the bindings for free variables.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, /, *args, **kwargs)
 |      Call self as a function.
 |  
 |  __get__(self, instance, owner, /)
 |      Return an attribute of instance, which is of type owner.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __annotations__
 |  
 |  __closure__
 |  
 |  __code__
 |  
 |  __defaults__
 |  
 |  __dict__
 |  
 |  __globals__
 |  
 |  __kwdefaults__
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.integrate.quadrature.__class__,integrate.quadrature,function,"Python Library Documentation: class function in module builtins

class function(object)
 |  function(code, globals[, name[, argdefs[, closure]]])
 |  
 |  Create a function object from a code object and a dictionary.
 |  The optional name string overrides the name from the code object.
 |  The optional argdefs tuple specifies the default argument values.
 |  The optional closure tuple supplies the bindings for free variables.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, /, *args, **kwargs)
 |      Call self as a function.
 |  
 |  __get__(self, instance, owner, /)
 |      Return an attribute of instance, which is of type owner.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __annotations__
 |  
 |  __closure__
 |  
 |  __code__
 |  
 |  __defaults__
 |  
 |  __dict__
 |  
 |  __globals__
 |  
 |  __kwdefaults__
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.interpolate._bsplines.BSpline,interpolate._bsplines,BSpline,"Python Library Documentation: class BSpline in module scipy.interpolate._bsplines

class BSpline(builtins.object)
 |  Univariate spline in the B-spline basis.
 |  
 |  .. math::
 |  
 |      S(x) = \sum_{j=0}^{n-1} c_j  B_{j, k; t}(x)
 |  
 |  where :math:`B_{j, k; t}` are B-spline basis functions of degree `k`
 |  and knots `t`.
 |  
 |  Parameters
 |  ----------
 |  t : ndarray, shape (n+k+1,)
 |      knots
 |  c : ndarray, shape (>=n, ...)
 |      spline coefficients
 |  k : int
 |      B-spline order
 |  extrapolate : bool or 'periodic', optional
 |      whether to extrapolate beyond the base interval, ``t[k] .. t[n]``,
 |      or to return nans.
 |      If True, extrapolates the first and last polynomial pieces of b-spline
 |      functions active on the base interval.
 |      If 'periodic', periodic extrapolation is used.
 |      Default is True.
 |  axis : int, optional
 |      Interpolation axis. Default is zero.
 |  
 |  Attributes
 |  ----------
 |  t : ndarray
 |      knot vector
 |  c : ndarray
 |      spline coefficients
 |  k : int
 |      spline degree
 |  extrapolate : bool
 |      If True, extrapolates the first and last polynomial pieces of b-spline
 |      functions active on the base interval.
 |  axis : int
 |      Interpolation axis.
 |  tck : tuple
 |      A read-only equivalent of ``(self.t, self.c, self.k)``
 |  
 |  Methods
 |  -------
 |  __call__
 |  basis_element
 |  derivative
 |  antiderivative
 |  integrate
 |  construct_fast
 |  
 |  Notes
 |  -----
 |  B-spline basis elements are defined via
 |  
 |  .. math::
 |  
 |      B_{i, 0}(x) = 1, \textrm{if $t_i \le x < t_{i+1}$, otherwise $0$,}
 |  
 |      B_{i, k}(x) = \frac{x - t_i}{t_{i+k} - t_i} B_{i, k-1}(x)
 |               + \frac{t_{i+k+1} - x}{t_{i+k+1} - t_{i+1}} B_{i+1, k-1}(x)
 |  
 |  **Implementation details**
 |  
 |  - At least ``k+1`` coefficients are required for a spline of degree `k`,
 |    so that ``n >= k+1``. Additional coefficients, ``c[j]`` with
 |    ``j > n``, are ignored.
 |  
 |  - B-spline basis elements of degree `k` form a partition of unity on the
 |    *base interval*, ``t[k] <= x <= t[n]``.
 |  
 |  
 |  Examples
 |  --------
 |  
 |  Translating the recursive definition of B-splines into Python code, we have:
 |  
 |  >>> def B(x, k, i, t):
 |  ...    if k == 0:
 |  ...       return 1.0 if t[i] <= x < t[i+1] else 0.0
 |  ...    if t[i+k] == t[i]:
 |  ...       c1 = 0.0
 |  ...    else:
 |  ...       c1 = (x - t[i])/(t[i+k] - t[i]) * B(x, k-1, i, t)
 |  ...    if t[i+k+1] == t[i+1]:
 |  ...       c2 = 0.0
 |  ...    else:
 |  ...       c2 = (t[i+k+1] - x)/(t[i+k+1] - t[i+1]) * B(x, k-1, i+1, t)
 |  ...    return c1 + c2
 |  
 |  >>> def bspline(x, t, c, k):
 |  ...    n = len(t) - k - 1
 |  ...    assert (n >= k+1) and (len(c) >= n)
 |  ...    return sum(c[i] * B(x, k, i, t) for i in range(n))
 |  
 |  Note that this is an inefficient (if straightforward) way to
 |  evaluate B-splines --- this spline class does it in an equivalent,
 |  but much more efficient way.
 |  
 |  Here we construct a quadratic spline function on the base interval
 |  ``2 <= x <= 4`` and compare with the naive way of evaluating the spline:
 |  
 |  >>> from scipy.interpolate import BSpline
 |  >>> k = 2
 |  >>> t = [0, 1, 2, 3, 4, 5, 6]
 |  >>> c = [-1, 2, 0, -1]
 |  >>> spl = BSpline(t, c, k)
 |  >>> spl(2.5)
 |  array(1.375)
 |  >>> bspline(2.5, t, c, k)
 |  1.375
 |  
 |  Note that outside of the base interval results differ. This is because
 |  `BSpline` extrapolates the first and last polynomial pieces of b-spline
 |  functions active on the base interval.
 |  
 |  >>> import matplotlib.pyplot as plt
 |  >>> fig, ax = plt.subplots()
 |  >>> xx = np.linspace(1.5, 4.5, 50)
 |  >>> ax.plot(xx, [bspline(x, t, c ,k) for x in xx], 'r-', lw=3, label='naive')
 |  >>> ax.plot(xx, spl(xx), 'b-', lw=4, alpha=0.7, label='BSpline')
 |  >>> ax.grid(True)
 |  >>> ax.legend(loc='best')
 |  >>> plt.show()
 |  
 |  
 |  References
 |  ----------
 |  .. [1] Tom Lyche and Knut Morken, Spline methods,
 |      http://www.uio.no/studier/emner/matnat/ifi/INF-MAT5340/v05/undervisningsmateriale/
 |  .. [2] Carl de Boor, A practical guide to splines, Springer, 2001.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, x, nu=0, extrapolate=None)
 |      Evaluate a spline function.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          points to evaluate the spline at.
 |      nu: int, optional
 |          derivative to evaluate (default is 0).
 |      extrapolate : bool or 'periodic', optional
 |          whether to extrapolate based on the first and last intervals
 |          or return nans. If 'periodic', periodic extrapolation is used.
 |          Default is `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Shape is determined by replacing the interpolation axis
 |          in the coefficient array with the shape of `x`.
 |  
 |  __init__(self, t, c, k, extrapolate=True, axis=0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  antiderivative(self, nu=1)
 |      Return a b-spline representing the antiderivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Antiderivative order. Default is 1.
 |      
 |      Returns
 |      -------
 |      b : BSpline object
 |          A new instance representing the antiderivative.
 |      
 |      Notes
 |      -----
 |      If antiderivative is computed and ``self.extrapolate='periodic'``,
 |      it will be set to False for the returned instance. This is done because
 |      the antiderivative is no longer periodic and its correct evaluation
 |      outside of the initially given x interval is difficult.
 |      
 |      See Also
 |      --------
 |      splder, splantider
 |  
 |  derivative(self, nu=1)
 |      Return a b-spline representing the derivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Derivative order.
 |          Default is 1.
 |      
 |      Returns
 |      -------
 |      b : BSpline object
 |          A new instance representing the derivative.
 |      
 |      See Also
 |      --------
 |      splder, splantider
 |  
 |  integrate(self, a, b, extrapolate=None)
 |      Compute a definite integral of the spline.
 |      
 |      Parameters
 |      ----------
 |      a : float
 |          Lower limit of integration.
 |      b : float
 |          Upper limit of integration.
 |      extrapolate : bool or 'periodic', optional
 |          whether to extrapolate beyond the base interval,
 |          ``t[k] .. t[-k-1]``, or take the spline to be zero outside of the
 |          base interval. If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      I : array_like
 |          Definite integral of the spline over the interval ``[a, b]``.
 |      
 |      Examples
 |      --------
 |      Construct the linear spline ``x if x < 1 else 2 - x`` on the base
 |      interval :math:`[0, 2]`, and integrate it
 |      
 |      >>> from scipy.interpolate import BSpline
 |      >>> b = BSpline.basis_element([0, 1, 2])
 |      >>> b.integrate(0, 1)
 |      array(0.5)
 |      
 |      If the integration limits are outside of the base interval, the result
 |      is controlled by the `extrapolate` parameter
 |      
 |      >>> b.integrate(-1, 1)
 |      array(0.0)
 |      >>> b.integrate(-1, 1, extrapolate=False)
 |      array(0.5)
 |      
 |      >>> import matplotlib.pyplot as plt
 |      >>> fig, ax = plt.subplots()
 |      >>> ax.grid(True)
 |      >>> ax.axvline(0, c='r', lw=5, alpha=0.5)  # base interval
 |      >>> ax.axvline(2, c='r', lw=5, alpha=0.5)
 |      >>> xx = [-1, 1, 2]
 |      >>> ax.plot(xx, b(xx))
 |      >>> plt.show()
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  basis_element(t, extrapolate=True) from builtins.type
 |      Return a B-spline basis element ``B(x | t[0], ..., t[k+1])``.
 |      
 |      Parameters
 |      ----------
 |      t : ndarray, shape (k+1,)
 |          internal knots
 |      extrapolate : bool or 'periodic', optional
 |          whether to extrapolate beyond the base interval, ``t[0] .. t[k+1]``,
 |          or to return nans.
 |          If 'periodic', periodic extrapolation is used.
 |          Default is True.
 |      
 |      Returns
 |      -------
 |      basis_element : callable
 |          A callable representing a B-spline basis element for the knot
 |          vector `t`.
 |      
 |      Notes
 |      -----
 |      The order of the b-spline, `k`, is inferred from the length of `t` as
 |      ``len(t)-2``. The knot vector is constructed by appending and prepending
 |      ``k+1`` elements to internal knots `t`.
 |      
 |      Examples
 |      --------
 |      
 |      Construct a cubic b-spline:
 |      
 |      >>> from scipy.interpolate import BSpline
 |      >>> b = BSpline.basis_element([0, 1, 2, 3, 4])
 |      >>> k = b.k
 |      >>> b.t[k:-k]
 |      array([ 0.,  1.,  2.,  3.,  4.])
 |      >>> k
 |      3
 |      
 |      Construct a second order b-spline on ``[0, 1, 1, 2]``, and compare
 |      to its explicit form:
 |      
 |      >>> t = [-1, 0, 1, 1, 2]
 |      >>> b = BSpline.basis_element(t[1:])
 |      >>> def f(x):
 |      ...     return np.where(x < 1, x*x, (2. - x)**2)
 |      
 |      >>> import matplotlib.pyplot as plt
 |      >>> fig, ax = plt.subplots()
 |      >>> x = np.linspace(0, 2, 51)
 |      >>> ax.plot(x, b(x), 'g', lw=3)
 |      >>> ax.plot(x, f(x), 'r', lw=8, alpha=0.4)
 |      >>> ax.grid(True)
 |      >>> plt.show()
 |  
 |  construct_fast(t, c, k, extrapolate=True, axis=0) from builtins.type
 |      Construct a spline without making checks.
 |      
 |      Accepts same parameters as the regular constructor. Input arrays
 |      `t` and `c` must of correct shape and dtype.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  tck
 |      Equivalent to ``(self.t, self.c, self.k)`` (read-only).
",class,"('(self, t, c, k, extrapolate=True, axis=0)',)",scipy,1.1.0,scipy.interpolate._bsplines.BSpline,interpolate._bsplines,BSpline,"Python Library Documentation: class BSpline in module scipy.interpolate._bsplines

class BSpline(builtins.object)
 |  Univariate spline in the B-spline basis.
 |  
 |  .. math::
 |  
 |      S(x) = \sum_{j=0}^{n-1} c_j  B_{j, k; t}(x)
 |  
 |  where :math:`B_{j, k; t}` are B-spline basis functions of degree `k`
 |  and knots `t`.
 |  
 |  Parameters
 |  ----------
 |  t : ndarray, shape (n+k+1,)
 |      knots
 |  c : ndarray, shape (>=n, ...)
 |      spline coefficients
 |  k : int
 |      B-spline order
 |  extrapolate : bool or 'periodic', optional
 |      whether to extrapolate beyond the base interval, ``t[k] .. t[n]``,
 |      or to return nans.
 |      If True, extrapolates the first and last polynomial pieces of b-spline
 |      functions active on the base interval.
 |      If 'periodic', periodic extrapolation is used.
 |      Default is True.
 |  axis : int, optional
 |      Interpolation axis. Default is zero.
 |  
 |  Attributes
 |  ----------
 |  t : ndarray
 |      knot vector
 |  c : ndarray
 |      spline coefficients
 |  k : int
 |      spline degree
 |  extrapolate : bool
 |      If True, extrapolates the first and last polynomial pieces of b-spline
 |      functions active on the base interval.
 |  axis : int
 |      Interpolation axis.
 |  tck : tuple
 |      A read-only equivalent of ``(self.t, self.c, self.k)``
 |  
 |  Methods
 |  -------
 |  __call__
 |  basis_element
 |  derivative
 |  antiderivative
 |  integrate
 |  construct_fast
 |  
 |  Notes
 |  -----
 |  B-spline basis elements are defined via
 |  
 |  .. math::
 |  
 |      B_{i, 0}(x) = 1, \textrm{if $t_i \le x < t_{i+1}$, otherwise $0$,}
 |  
 |      B_{i, k}(x) = \frac{x - t_i}{t_{i+k} - t_i} B_{i, k-1}(x)
 |               + \frac{t_{i+k+1} - x}{t_{i+k+1} - t_{i+1}} B_{i+1, k-1}(x)
 |  
 |  **Implementation details**
 |  
 |  - At least ``k+1`` coefficients are required for a spline of degree `k`,
 |    so that ``n >= k+1``. Additional coefficients, ``c[j]`` with
 |    ``j > n``, are ignored.
 |  
 |  - B-spline basis elements of degree `k` form a partition of unity on the
 |    *base interval*, ``t[k] <= x <= t[n]``.
 |  
 |  
 |  Examples
 |  --------
 |  
 |  Translating the recursive definition of B-splines into Python code, we have:
 |  
 |  >>> def B(x, k, i, t):
 |  ...    if k == 0:
 |  ...       return 1.0 if t[i] <= x < t[i+1] else 0.0
 |  ...    if t[i+k] == t[i]:
 |  ...       c1 = 0.0
 |  ...    else:
 |  ...       c1 = (x - t[i])/(t[i+k] - t[i]) * B(x, k-1, i, t)
 |  ...    if t[i+k+1] == t[i+1]:
 |  ...       c2 = 0.0
 |  ...    else:
 |  ...       c2 = (t[i+k+1] - x)/(t[i+k+1] - t[i+1]) * B(x, k-1, i+1, t)
 |  ...    return c1 + c2
 |  
 |  >>> def bspline(x, t, c, k):
 |  ...    n = len(t) - k - 1
 |  ...    assert (n >= k+1) and (len(c) >= n)
 |  ...    return sum(c[i] * B(x, k, i, t) for i in range(n))
 |  
 |  Note that this is an inefficient (if straightforward) way to
 |  evaluate B-splines --- this spline class does it in an equivalent,
 |  but much more efficient way.
 |  
 |  Here we construct a quadratic spline function on the base interval
 |  ``2 <= x <= 4`` and compare with the naive way of evaluating the spline:
 |  
 |  >>> from scipy.interpolate import BSpline
 |  >>> k = 2
 |  >>> t = [0, 1, 2, 3, 4, 5, 6]
 |  >>> c = [-1, 2, 0, -1]
 |  >>> spl = BSpline(t, c, k)
 |  >>> spl(2.5)
 |  array(1.375)
 |  >>> bspline(2.5, t, c, k)
 |  1.375
 |  
 |  Note that outside of the base interval results differ. This is because
 |  `BSpline` extrapolates the first and last polynomial pieces of b-spline
 |  functions active on the base interval.
 |  
 |  >>> import matplotlib.pyplot as plt
 |  >>> fig, ax = plt.subplots()
 |  >>> xx = np.linspace(1.5, 4.5, 50)
 |  >>> ax.plot(xx, [bspline(x, t, c ,k) for x in xx], 'r-', lw=3, label='naive')
 |  >>> ax.plot(xx, spl(xx), 'b-', lw=4, alpha=0.7, label='BSpline')
 |  >>> ax.grid(True)
 |  >>> ax.legend(loc='best')
 |  >>> plt.show()
 |  
 |  
 |  References
 |  ----------
 |  .. [1] Tom Lyche and Knut Morken, Spline methods,
 |      http://www.uio.no/studier/emner/matnat/ifi/INF-MAT5340/v05/undervisningsmateriale/
 |  .. [2] Carl de Boor, A practical guide to splines, Springer, 2001.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, x, nu=0, extrapolate=None)
 |      Evaluate a spline function.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          points to evaluate the spline at.
 |      nu: int, optional
 |          derivative to evaluate (default is 0).
 |      extrapolate : bool or 'periodic', optional
 |          whether to extrapolate based on the first and last intervals
 |          or return nans. If 'periodic', periodic extrapolation is used.
 |          Default is `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Shape is determined by replacing the interpolation axis
 |          in the coefficient array with the shape of `x`.
 |  
 |  __init__(self, t, c, k, extrapolate=True, axis=0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  antiderivative(self, nu=1)
 |      Return a b-spline representing the antiderivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Antiderivative order. Default is 1.
 |      
 |      Returns
 |      -------
 |      b : BSpline object
 |          A new instance representing the antiderivative.
 |      
 |      Notes
 |      -----
 |      If antiderivative is computed and ``self.extrapolate='periodic'``,
 |      it will be set to False for the returned instance. This is done because
 |      the antiderivative is no longer periodic and its correct evaluation
 |      outside of the initially given x interval is difficult.
 |      
 |      See Also
 |      --------
 |      splder, splantider
 |  
 |  derivative(self, nu=1)
 |      Return a b-spline representing the derivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Derivative order.
 |          Default is 1.
 |      
 |      Returns
 |      -------
 |      b : BSpline object
 |          A new instance representing the derivative.
 |      
 |      See Also
 |      --------
 |      splder, splantider
 |  
 |  integrate(self, a, b, extrapolate=None)
 |      Compute a definite integral of the spline.
 |      
 |      Parameters
 |      ----------
 |      a : float
 |          Lower limit of integration.
 |      b : float
 |          Upper limit of integration.
 |      extrapolate : bool or 'periodic', optional
 |          whether to extrapolate beyond the base interval,
 |          ``t[k] .. t[-k-1]``, or take the spline to be zero outside of the
 |          base interval. If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      I : array_like
 |          Definite integral of the spline over the interval ``[a, b]``.
 |      
 |      Examples
 |      --------
 |      Construct the linear spline ``x if x < 1 else 2 - x`` on the base
 |      interval :math:`[0, 2]`, and integrate it
 |      
 |      >>> from scipy.interpolate import BSpline
 |      >>> b = BSpline.basis_element([0, 1, 2])
 |      >>> b.integrate(0, 1)
 |      array(0.5)
 |      
 |      If the integration limits are outside of the base interval, the result
 |      is controlled by the `extrapolate` parameter
 |      
 |      >>> b.integrate(-1, 1)
 |      array(0.0)
 |      >>> b.integrate(-1, 1, extrapolate=False)
 |      array(0.5)
 |      
 |      >>> import matplotlib.pyplot as plt
 |      >>> fig, ax = plt.subplots()
 |      >>> ax.grid(True)
 |      >>> ax.axvline(0, c='r', lw=5, alpha=0.5)  # base interval
 |      >>> ax.axvline(2, c='r', lw=5, alpha=0.5)
 |      >>> xx = [-1, 1, 2]
 |      >>> ax.plot(xx, b(xx))
 |      >>> plt.show()
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  basis_element(t, extrapolate=True) from builtins.type
 |      Return a B-spline basis element ``B(x | t[0], ..., t[k+1])``.
 |      
 |      Parameters
 |      ----------
 |      t : ndarray, shape (k+1,)
 |          internal knots
 |      extrapolate : bool or 'periodic', optional
 |          whether to extrapolate beyond the base interval, ``t[0] .. t[k+1]``,
 |          or to return nans.
 |          If 'periodic', periodic extrapolation is used.
 |          Default is True.
 |      
 |      Returns
 |      -------
 |      basis_element : callable
 |          A callable representing a B-spline basis element for the knot
 |          vector `t`.
 |      
 |      Notes
 |      -----
 |      The order of the b-spline, `k`, is inferred from the length of `t` as
 |      ``len(t)-2``. The knot vector is constructed by appending and prepending
 |      ``k+1`` elements to internal knots `t`.
 |      
 |      Examples
 |      --------
 |      
 |      Construct a cubic b-spline:
 |      
 |      >>> from scipy.interpolate import BSpline
 |      >>> b = BSpline.basis_element([0, 1, 2, 3, 4])
 |      >>> k = b.k
 |      >>> b.t[k:-k]
 |      array([ 0.,  1.,  2.,  3.,  4.])
 |      >>> k
 |      3
 |      
 |      Construct a second order b-spline on ``[0, 1, 1, 2]``, and compare
 |      to its explicit form:
 |      
 |      >>> t = [-1, 0, 1, 1, 2]
 |      >>> b = BSpline.basis_element(t[1:])
 |      >>> def f(x):
 |      ...     return np.where(x < 1, x*x, (2. - x)**2)
 |      
 |      >>> import matplotlib.pyplot as plt
 |      >>> fig, ax = plt.subplots()
 |      >>> x = np.linspace(0, 2, 51)
 |      >>> ax.plot(x, b(x), 'g', lw=3)
 |      >>> ax.plot(x, f(x), 'r', lw=8, alpha=0.4)
 |      >>> ax.grid(True)
 |      >>> plt.show()
 |  
 |  construct_fast(t, c, k, extrapolate=True, axis=0) from builtins.type
 |      Construct a spline without making checks.
 |      
 |      Accepts same parameters as the regular constructor. Input arrays
 |      `t` and `c` must of correct shape and dtype.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  tck
 |      Equivalent to ``(self.t, self.c, self.k)`` (read-only).
",class,"('self', 't', 'c', 'k', 'extrapolate', 'axis')","(nan, nan, nan, nan, True, 0)","(nan, nan, nan, nan, 'bool', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, t, c, k, extrapolate=True, axis=0)',)"
scipy,1.1.0,scipy.interpolate._bsplines.BSpline.basis_element,interpolate._bsplines.BSpline,basis_element,"Python Library Documentation: method basis_element in module scipy.interpolate._bsplines

basis_element(t, extrapolate=True) method of builtins.type instance
    Return a B-spline basis element ``B(x | t[0], ..., t[k+1])``.
    
    Parameters
    ----------
    t : ndarray, shape (k+1,)
        internal knots
    extrapolate : bool or 'periodic', optional
        whether to extrapolate beyond the base interval, ``t[0] .. t[k+1]``,
        or to return nans.
        If 'periodic', periodic extrapolation is used.
        Default is True.
    
    Returns
    -------
    basis_element : callable
        A callable representing a B-spline basis element for the knot
        vector `t`.
    
    Notes
    -----
    The order of the b-spline, `k`, is inferred from the length of `t` as
    ``len(t)-2``. The knot vector is constructed by appending and prepending
    ``k+1`` elements to internal knots `t`.
    
    Examples
    --------
    
    Construct a cubic b-spline:
    
    >>> from scipy.interpolate import BSpline
    >>> b = BSpline.basis_element([0, 1, 2, 3, 4])
    >>> k = b.k
    >>> b.t[k:-k]
    array([ 0.,  1.,  2.,  3.,  4.])
    >>> k
    3
    
    Construct a second order b-spline on ``[0, 1, 1, 2]``, and compare
    to its explicit form:
    
    >>> t = [-1, 0, 1, 1, 2]
    >>> b = BSpline.basis_element(t[1:])
    >>> def f(x):
    ...     return np.where(x < 1, x*x, (2. - x)**2)
    
    >>> import matplotlib.pyplot as plt
    >>> fig, ax = plt.subplots()
    >>> x = np.linspace(0, 2, 51)
    >>> ax.plot(x, b(x), 'g', lw=3)
    >>> ax.plot(x, f(x), 'r', lw=8, alpha=0.4)
    >>> ax.grid(True)
    >>> plt.show()
",method,"('(t, extrapolate=True)',)",scipy,1.1.0,scipy.interpolate._bsplines.BSpline.basis_element,interpolate._bsplines.BSpline,basis_element,"Python Library Documentation: method basis_element in module scipy.interpolate._bsplines

basis_element(t, extrapolate=True) method of builtins.type instance
    Return a B-spline basis element ``B(x | t[0], ..., t[k+1])``.
    
    Parameters
    ----------
    t : ndarray, shape (k+1,)
        internal knots
    extrapolate : bool or 'periodic', optional
        whether to extrapolate beyond the base interval, ``t[0] .. t[k+1]``,
        or to return nans.
        If 'periodic', periodic extrapolation is used.
        Default is True.
    
    Returns
    -------
    basis_element : callable
        A callable representing a B-spline basis element for the knot
        vector `t`.
    
    Notes
    -----
    The order of the b-spline, `k`, is inferred from the length of `t` as
    ``len(t)-2``. The knot vector is constructed by appending and prepending
    ``k+1`` elements to internal knots `t`.
    
    Examples
    --------
    
    Construct a cubic b-spline:
    
    >>> from scipy.interpolate import BSpline
    >>> b = BSpline.basis_element([0, 1, 2, 3, 4])
    >>> k = b.k
    >>> b.t[k:-k]
    array([ 0.,  1.,  2.,  3.,  4.])
    >>> k
    3
    
    Construct a second order b-spline on ``[0, 1, 1, 2]``, and compare
    to its explicit form:
    
    >>> t = [-1, 0, 1, 1, 2]
    >>> b = BSpline.basis_element(t[1:])
    >>> def f(x):
    ...     return np.where(x < 1, x*x, (2. - x)**2)
    
    >>> import matplotlib.pyplot as plt
    >>> fig, ax = plt.subplots()
    >>> x = np.linspace(0, 2, 51)
    >>> ax.plot(x, b(x), 'g', lw=3)
    >>> ax.plot(x, f(x), 'r', lw=8, alpha=0.4)
    >>> ax.grid(True)
    >>> plt.show()
",method,"('cls', 't', 'extrapolate')","(nan, nan, True)","(nan, nan, 'bool')","('arg_info', 'arg_info', 'arg_info')","('(t, extrapolate=True)',)"
scipy,1.1.0,scipy.interpolate._bsplines.BSpline.construct_fast,interpolate._bsplines.BSpline,construct_fast,"Python Library Documentation: method construct_fast in module scipy.interpolate._bsplines

construct_fast(t, c, k, extrapolate=True, axis=0) method of builtins.type instance
    Construct a spline without making checks.
    
    Accepts same parameters as the regular constructor. Input arrays
    `t` and `c` must of correct shape and dtype.
",method,"('(t, c, k, extrapolate=True, axis=0)',)",scipy,1.1.0,scipy.interpolate._bsplines.BSpline.construct_fast,interpolate._bsplines.BSpline,construct_fast,"Python Library Documentation: method construct_fast in module scipy.interpolate._bsplines

construct_fast(t, c, k, extrapolate=True, axis=0) method of builtins.type instance
    Construct a spline without making checks.
    
    Accepts same parameters as the regular constructor. Input arrays
    `t` and `c` must of correct shape and dtype.
",method,"('cls', 't', 'c', 'k', 'extrapolate', 'axis')","(nan, nan, nan, nan, True, 0)","(nan, nan, nan, nan, 'bool', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(t, c, k, extrapolate=True, axis=0)',)"
scipy,1.1.0,scipy.interpolate._bsplines.LinAlgError,interpolate._bsplines,LinAlgError,"Python Library Documentation: class LinAlgError in module numpy.linalg.linalg

class LinAlgError(builtins.Exception)
 |  Generic Python-exception-derived object raised by linalg functions.
 |  
 |  General purpose exception class, derived from Python's exception.Exception
 |  class, programmatically raised in linalg functions when a Linear
 |  Algebra-related condition would prevent further correct execution of the
 |  function.
 |  
 |  Parameters
 |  ----------
 |  None
 |  
 |  Examples
 |  --------
 |  >>> from numpy import linalg as LA
 |  >>> LA.inv(np.zeros((2,2)))
 |  Traceback (most recent call last):
 |    File ""<stdin>"", line 1, in <module>
 |    File ""...linalg.py"", line 350,
 |      in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
 |    File ""...linalg.py"", line 249,
 |      in solve
 |      raise LinAlgError('Singular matrix')
 |  numpy.linalg.LinAlgError: Singular matrix
 |  
 |  Method resolution order:
 |      LinAlgError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.interpolate._bsplines.LinAlgError,interpolate._bsplines,LinAlgError,"Python Library Documentation: class LinAlgError in module numpy.linalg.linalg

class LinAlgError(builtins.Exception)
 |  Generic Python-exception-derived object raised by linalg functions.
 |  
 |  General purpose exception class, derived from Python's exception.Exception
 |  class, programmatically raised in linalg functions when a Linear
 |  Algebra-related condition would prevent further correct execution of the
 |  function.
 |  
 |  Parameters
 |  ----------
 |  None
 |  
 |  Examples
 |  --------
 |  >>> from numpy import linalg as LA
 |  >>> LA.inv(np.zeros((2,2)))
 |  Traceback (most recent call last):
 |    File ""<stdin>"", line 1, in <module>
 |    File ""...linalg.py"", line 350,
 |      in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
 |    File ""...linalg.py"", line 249,
 |      in solve
 |      raise LinAlgError('Singular matrix')
 |  numpy.linalg.LinAlgError: Singular matrix
 |  
 |  Method resolution order:
 |      LinAlgError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.interpolate._bsplines._as_float_array,interpolate._bsplines,_as_float_array,"Python Library Documentation: function _as_float_array in module scipy.interpolate._bsplines

_as_float_array(x, check_finite=False)
    Convert the input into a C contiguous float array.
    
    NB: Upcasts half- and single-precision floats to double precision.
",function,"('(x, check_finite=False)',)",scipy,1.1.0,scipy.interpolate._bsplines._as_float_array,interpolate._bsplines,_as_float_array,"Python Library Documentation: function _as_float_array in module scipy.interpolate._bsplines

_as_float_array(x, check_finite=False)
    Convert the input into a C contiguous float array.
    
    NB: Upcasts half- and single-precision floats to double precision.
",function,"('x', 'check_finite')","(nan, False)","(nan, 'bool')","('arg_info', 'arg_info')","('(x, check_finite=False)',)"
scipy,1.1.0,scipy.interpolate._bsplines._augknt,interpolate._bsplines,_augknt,"Python Library Documentation: function _augknt in module scipy.interpolate._bsplines

_augknt(x, k)
    Construct a knot vector appropriate for the order-k interpolation.
",function,"('(x, k)',)",scipy,1.1.0,scipy.interpolate._bsplines._augknt,interpolate._bsplines,_augknt,"Python Library Documentation: function _augknt in module scipy.interpolate._bsplines

_augknt(x, k)
    Construct a knot vector appropriate for the order-k interpolation.
",function,"('x', 'k')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(x, k)',)"
scipy,1.1.0,scipy.interpolate._bsplines._convert_string_aliases,interpolate._bsplines,_convert_string_aliases,"Python Library Documentation: function _convert_string_aliases in module scipy.interpolate._bsplines

_convert_string_aliases(deriv, target_shape)
",function,"('(deriv, target_shape)',)",scipy,1.1.0,scipy.interpolate._bsplines._convert_string_aliases,interpolate._bsplines,_convert_string_aliases,"Python Library Documentation: function _convert_string_aliases in module scipy.interpolate._bsplines

_convert_string_aliases(deriv, target_shape)
",function,"('deriv', 'target_shape')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(deriv, target_shape)',)"
scipy,1.1.0,scipy.interpolate._bsplines._get_dtype,interpolate._bsplines,_get_dtype,"Python Library Documentation: function _get_dtype in module scipy.interpolate._bsplines

_get_dtype(dtype)
    Return np.complex128 for complex dtypes, np.float64 otherwise.
",function,"('(dtype)',)",scipy,1.1.0,scipy.interpolate._bsplines._get_dtype,interpolate._bsplines,_get_dtype,"Python Library Documentation: function _get_dtype in module scipy.interpolate._bsplines

_get_dtype(dtype)
    Return np.complex128 for complex dtypes, np.float64 otherwise.
",function,"('dtype',)","(nan,)","(nan,)","('arg_info',)","('(dtype)',)"
scipy,1.1.0,scipy.interpolate._bsplines._not_a_knot,interpolate._bsplines,_not_a_knot,"Python Library Documentation: function _not_a_knot in module scipy.interpolate._bsplines

_not_a_knot(x, k)
    Given data x, construct the knot vector w/ not-a-knot BC.
    cf de Boor, XIII(12).
",function,"('(x, k)',)",scipy,1.1.0,scipy.interpolate._bsplines._not_a_knot,interpolate._bsplines,_not_a_knot,"Python Library Documentation: function _not_a_knot in module scipy.interpolate._bsplines

_not_a_knot(x, k)
    Given data x, construct the knot vector w/ not-a-knot BC.
    cf de Boor, XIII(12).
",function,"('x', 'k')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(x, k)',)"
scipy,1.1.0,scipy.interpolate._bsplines.cho_solve_banded,interpolate._bsplines,cho_solve_banded,"Python Library Documentation: function cho_solve_banded in module scipy.linalg.decomp_cholesky

cho_solve_banded(cb_and_lower, b, overwrite_b=False, check_finite=True)
    Solve the linear equations ``A x = b``, given the Cholesky factorization of
    the banded hermitian ``A``.
    
    Parameters
    ----------
    (cb, lower) : tuple, (ndarray, bool)
        `cb` is the Cholesky factorization of A, as given by cholesky_banded.
        `lower` must be the same value that was given to cholesky_banded.
    b : array_like
        Right-hand side
    overwrite_b : bool, optional
        If True, the function will overwrite the values in `b`.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : array
        The solution to the system A x = b
    
    See also
    --------
    cholesky_banded : Cholesky factorization of a banded matrix
    
    Notes
    -----
    
    .. versionadded:: 0.8.0
    
    Examples
    --------
    >>> from scipy.linalg import cholesky_banded, cho_solve_banded
    >>> Ab = np.array([[0, 0, 1j, 2, 3j], [0, -1, -2, 3, 4], [9, 8, 7, 6, 9]])
    >>> A = np.diag(Ab[0,2:], k=2) + np.diag(Ab[1,1:], k=1)
    >>> A = A + A.conj().T + np.diag(Ab[2, :])
    >>> c = cholesky_banded(Ab)
    >>> x = cho_solve_banded((c, False), np.ones(5))
    >>> np.allclose(A @ x - np.ones(5), np.zeros(5))
    True
",function,"('(cb_and_lower, b, overwrite_b=False, check_finite=True)',)",scipy,1.1.0,scipy.interpolate._bsplines.cho_solve_banded,interpolate._bsplines,cho_solve_banded,"Python Library Documentation: function cho_solve_banded in module scipy.linalg.decomp_cholesky

cho_solve_banded(cb_and_lower, b, overwrite_b=False, check_finite=True)
    Solve the linear equations ``A x = b``, given the Cholesky factorization of
    the banded hermitian ``A``.
    
    Parameters
    ----------
    (cb, lower) : tuple, (ndarray, bool)
        `cb` is the Cholesky factorization of A, as given by cholesky_banded.
        `lower` must be the same value that was given to cholesky_banded.
    b : array_like
        Right-hand side
    overwrite_b : bool, optional
        If True, the function will overwrite the values in `b`.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : array
        The solution to the system A x = b
    
    See also
    --------
    cholesky_banded : Cholesky factorization of a banded matrix
    
    Notes
    -----
    
    .. versionadded:: 0.8.0
    
    Examples
    --------
    >>> from scipy.linalg import cholesky_banded, cho_solve_banded
    >>> Ab = np.array([[0, 0, 1j, 2, 3j], [0, -1, -2, 3, 4], [9, 8, 7, 6, 9]])
    >>> A = np.diag(Ab[0,2:], k=2) + np.diag(Ab[1,1:], k=1)
    >>> A = A + A.conj().T + np.diag(Ab[2, :])
    >>> c = cholesky_banded(Ab)
    >>> x = cho_solve_banded((c, False), np.ones(5))
    >>> np.allclose(A @ x - np.ones(5), np.zeros(5))
    True
",function,"('cb_and_lower', 'b', 'overwrite_b', 'check_finite')","(nan, nan, False, True)","(nan, nan, 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(cb_and_lower, b, overwrite_b=False, check_finite=True)',)"
scipy,1.1.0,scipy.interpolate._bsplines.cholesky_banded,interpolate._bsplines,cholesky_banded,"Python Library Documentation: function cholesky_banded in module scipy.linalg.decomp_cholesky

cholesky_banded(ab, overwrite_ab=False, lower=False, check_finite=True)
    Cholesky decompose a banded Hermitian positive-definite matrix
    
    The matrix a is stored in ab either in lower diagonal or upper
    diagonal ordered form::
    
        ab[u + i - j, j] == a[i,j]        (if upper form; i <= j)
        ab[    i - j, j] == a[i,j]        (if lower form; i >= j)
    
    Example of ab (shape of a is (6,6), u=2)::
    
        upper form:
        *   *   a02 a13 a24 a35
        *   a01 a12 a23 a34 a45
        a00 a11 a22 a33 a44 a55
    
        lower form:
        a00 a11 a22 a33 a44 a55
        a10 a21 a32 a43 a54 *
        a20 a31 a42 a53 *   *
    
    Parameters
    ----------
    ab : (u + 1, M) array_like
        Banded matrix
    overwrite_ab : bool, optional
        Discard data in ab (may enhance performance)
    lower : bool, optional
        Is the matrix in the lower form. (Default is upper form)
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    c : (u + 1, M) ndarray
        Cholesky factorization of a, in the same banded format as ab
    
    Examples
    --------
    >>> from scipy.linalg import cholesky_banded
    >>> from numpy import allclose, zeros, diag
    >>> Ab = np.array([[0, 0, 1j, 2, 3j], [0, -1, -2, 3, 4], [9, 8, 7, 6, 9]])
    >>> A = np.diag(Ab[0,2:], k=2) + np.diag(Ab[1,1:], k=1)
    >>> A = A + A.conj().T + np.diag(Ab[2, :])
    >>> c = cholesky_banded(Ab)
    >>> C = np.diag(c[0, 2:], k=2) + np.diag(c[1, 1:], k=1) + np.diag(c[2, :])
    >>> np.allclose(C.conj().T @ C - A, np.zeros((5, 5)))
    True
",function,"('(ab, overwrite_ab=False, lower=False, check_finite=True)',)",scipy,1.1.0,scipy.interpolate._bsplines.cholesky_banded,interpolate._bsplines,cholesky_banded,"Python Library Documentation: function cholesky_banded in module scipy.linalg.decomp_cholesky

cholesky_banded(ab, overwrite_ab=False, lower=False, check_finite=True)
    Cholesky decompose a banded Hermitian positive-definite matrix
    
    The matrix a is stored in ab either in lower diagonal or upper
    diagonal ordered form::
    
        ab[u + i - j, j] == a[i,j]        (if upper form; i <= j)
        ab[    i - j, j] == a[i,j]        (if lower form; i >= j)
    
    Example of ab (shape of a is (6,6), u=2)::
    
        upper form:
        *   *   a02 a13 a24 a35
        *   a01 a12 a23 a34 a45
        a00 a11 a22 a33 a44 a55
    
        lower form:
        a00 a11 a22 a33 a44 a55
        a10 a21 a32 a43 a54 *
        a20 a31 a42 a53 *   *
    
    Parameters
    ----------
    ab : (u + 1, M) array_like
        Banded matrix
    overwrite_ab : bool, optional
        Discard data in ab (may enhance performance)
    lower : bool, optional
        Is the matrix in the lower form. (Default is upper form)
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    c : (u + 1, M) ndarray
        Cholesky factorization of a, in the same banded format as ab
    
    Examples
    --------
    >>> from scipy.linalg import cholesky_banded
    >>> from numpy import allclose, zeros, diag
    >>> Ab = np.array([[0, 0, 1j, 2, 3j], [0, -1, -2, 3, 4], [9, 8, 7, 6, 9]])
    >>> A = np.diag(Ab[0,2:], k=2) + np.diag(Ab[1,1:], k=1)
    >>> A = A + A.conj().T + np.diag(Ab[2, :])
    >>> c = cholesky_banded(Ab)
    >>> C = np.diag(c[0, 2:], k=2) + np.diag(c[1, 1:], k=1) + np.diag(c[2, :])
    >>> np.allclose(C.conj().T @ C - A, np.zeros((5, 5)))
    True
",function,"('ab', 'overwrite_ab', 'lower', 'check_finite')","(nan, False, False, True)","(nan, 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(ab, overwrite_ab=False, lower=False, check_finite=True)',)"
scipy,1.1.0,scipy.interpolate._bsplines.get_lapack_funcs,interpolate._bsplines,get_lapack_funcs,"Python Library Documentation: function get_lapack_funcs in module scipy.linalg.lapack

get_lapack_funcs(names, arrays=(), dtype=None)
    Return available LAPACK function objects from names.
    
    Arrays are used to determine the optimal prefix of LAPACK routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of LAPACK functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of LAPACK
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In LAPACK, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively, and
    are stored in attribute ``typecode`` of the returned functions.
    
    Examples
    --------
    Suppose we would like to use '?lange' routine which computes the selected
    norm of an array. We pass our array in order to get the correct 'lange'
    flavor.
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_lange = LA.get_lapack_funcs('lange', (a,))
    >>> x_lange.typecode
    'd'
    >>> x_lange = LA.get_lapack_funcs('lange',(a*1j,))
    >>> x_lange.typecode
    'z'
    
    Several LAPACK routines work best when its internal WORK array has
    the optimal size (big enough for fast computation and small enough to
    avoid waste of memory). This size is determined also by a dedicated query
    to the function which is often wrapped as a standalone function and
    commonly denoted as ``###_lwork``. Below is an example for ``?sysv``
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(1000,1000)
    >>> b = np.random.rand(1000,1)*1j
    >>> # We pick up zsysv and zsysv_lwork due to b array
    ... xsysv, xlwork = LA.get_lapack_funcs(('sysv', 'sysv_lwork'), (a, b))
    >>> opt_lwork, _ = xlwork(a.shape[0])  # returns a complex for 'z' prefix
    >>> udut, ipiv, x, info = xsysv(a, b, lwork=int(opt_lwork.real))
",function,"('(names, arrays=(), dtype=None)',)",scipy,1.1.0,scipy.interpolate._bsplines.get_lapack_funcs,interpolate._bsplines,get_lapack_funcs,"Python Library Documentation: function get_lapack_funcs in module scipy.linalg.lapack

get_lapack_funcs(names, arrays=(), dtype=None)
    Return available LAPACK function objects from names.
    
    Arrays are used to determine the optimal prefix of LAPACK routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of LAPACK functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of LAPACK
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In LAPACK, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively, and
    are stored in attribute ``typecode`` of the returned functions.
    
    Examples
    --------
    Suppose we would like to use '?lange' routine which computes the selected
    norm of an array. We pass our array in order to get the correct 'lange'
    flavor.
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_lange = LA.get_lapack_funcs('lange', (a,))
    >>> x_lange.typecode
    'd'
    >>> x_lange = LA.get_lapack_funcs('lange',(a*1j,))
    >>> x_lange.typecode
    'z'
    
    Several LAPACK routines work best when its internal WORK array has
    the optimal size (big enough for fast computation and small enough to
    avoid waste of memory). This size is determined also by a dedicated query
    to the function which is often wrapped as a standalone function and
    commonly denoted as ``###_lwork``. Below is an example for ``?sysv``
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(1000,1000)
    >>> b = np.random.rand(1000,1)*1j
    >>> # We pick up zsysv and zsysv_lwork due to b array
    ... xsysv, xlwork = LA.get_lapack_funcs(('sysv', 'sysv_lwork'), (a, b))
    >>> opt_lwork, _ = xlwork(a.shape[0])  # returns a complex for 'z' prefix
    >>> udut, ipiv, x, info = xsysv(a, b, lwork=int(opt_lwork.real))
",function,"('names', 'arrays', 'dtype')","(nan, (), None)","(nan, 'tuple', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(names, arrays=(), dtype=None)',)"
scipy,1.1.0,scipy.interpolate._bsplines.make_interp_spline,interpolate._bsplines,make_interp_spline,"Python Library Documentation: function make_interp_spline in module scipy.interpolate._bsplines

make_interp_spline(x, y, k=3, t=None, bc_type=None, axis=0, check_finite=True)
    Compute the (coefficients of) interpolating B-spline.
    
    Parameters
    ----------
    x : array_like, shape (n,)
        Abscissas.
    y : array_like, shape (n, ...)
        Ordinates.
    k : int, optional
        B-spline degree. Default is cubic, k=3.
    t : array_like, shape (nt + k + 1,), optional.
        Knots.
        The number of knots needs to agree with the number of datapoints and
        the number of derivatives at the edges. Specifically, ``nt - n`` must
        equal ``len(deriv_l) + len(deriv_r)``.
    bc_type : 2-tuple or None
        Boundary conditions.
        Default is None, which means choosing the boundary conditions
        automatically. Otherwise, it must be a length-two tuple where the first
        element sets the boundary conditions at ``x[0]`` and the second
        element sets the boundary conditions at ``x[-1]``. Each of these must
        be an iterable of pairs ``(order, value)`` which gives the values of
        derivatives of specified orders at the given edge of the interpolation
        interval.
        Alternatively, the following string aliases are recognized:
    
        * ``""clamped""``: The first derivatives at the ends are zero. This is
           equivalent to ``bc_type=((1, 0.0), (1, 0.0))``.
        * ``""natural""``: The second derivatives at ends are zero. This is
          equivalent to ``bc_type=((2, 0.0), (2, 0.0))``.
        * ``""not-a-knot""`` (default): The first and second segments are the same
          polynomial. This is equivalent to having ``bc_type=None``.
    
    axis : int, optional
        Interpolation axis. Default is 0.
    check_finite : bool, optional
        Whether to check that the input arrays contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default is True.
    
    Returns
    -------
    b : a BSpline object of the degree ``k`` and with knots ``t``.
    
    Examples
    --------
    
    Use cubic interpolation on Chebyshev nodes:
    
    >>> def cheb_nodes(N):
    ...     jj = 2.*np.arange(N) + 1
    ...     x = np.cos(np.pi * jj / 2 / N)[::-1]
    ...     return x
    
    >>> x = cheb_nodes(20)
    >>> y = np.sqrt(1 - x**2)
    
    >>> from scipy.interpolate import BSpline, make_interp_spline
    >>> b = make_interp_spline(x, y)
    >>> np.allclose(b(x), y)
    True
    
    Note that the default is a cubic spline with a not-a-knot boundary condition
    
    >>> b.k
    3
    
    Here we use a 'natural' spline, with zero 2nd derivatives at edges:
    
    >>> l, r = [(2, 0.0)], [(2, 0.0)]
    >>> b_n = make_interp_spline(x, y, bc_type=(l, r))  # or, bc_type=""natural""
    >>> np.allclose(b_n(x), y)
    True
    >>> x0, x1 = x[0], x[-1]
    >>> np.allclose([b_n(x0, 2), b_n(x1, 2)], [0, 0])
    True
    
    Interpolation of parametric curves is also supported. As an example, we
    compute a discretization of a snail curve in polar coordinates
    
    >>> phi = np.linspace(0, 2.*np.pi, 40)
    >>> r = 0.3 + np.cos(phi)
    >>> x, y = r*np.cos(phi), r*np.sin(phi)  # convert to Cartesian coordinates
    
    Build an interpolating curve, parameterizing it by the angle
    
    >>> from scipy.interpolate import make_interp_spline
    >>> spl = make_interp_spline(phi, np.c_[x, y])
    
    Evaluate the interpolant on a finer grid (note that we transpose the result
    to unpack it into a pair of x- and y-arrays)
    
    >>> phi_new = np.linspace(0, 2.*np.pi, 100)
    >>> x_new, y_new = spl(phi_new).T
    
    Plot the result
    
    >>> import matplotlib.pyplot as plt
    >>> plt.plot(x, y, 'o')
    >>> plt.plot(x_new, y_new, '-')
    >>> plt.show()
    
    See Also
    --------
    BSpline : base class representing the B-spline objects
    CubicSpline : a cubic spline in the polynomial basis
    make_lsq_spline : a similar factory function for spline fitting
    UnivariateSpline : a wrapper over FITPACK spline fitting routines
    splrep : a wrapper over FITPACK spline fitting routines
",function,"('(x, y, k=3, t=None, bc_type=None, axis=0, check_finite=True)',)",scipy,1.1.0,scipy.interpolate._bsplines.make_interp_spline,interpolate._bsplines,make_interp_spline,"Python Library Documentation: function make_interp_spline in module scipy.interpolate._bsplines

make_interp_spline(x, y, k=3, t=None, bc_type=None, axis=0, check_finite=True)
    Compute the (coefficients of) interpolating B-spline.
    
    Parameters
    ----------
    x : array_like, shape (n,)
        Abscissas.
    y : array_like, shape (n, ...)
        Ordinates.
    k : int, optional
        B-spline degree. Default is cubic, k=3.
    t : array_like, shape (nt + k + 1,), optional.
        Knots.
        The number of knots needs to agree with the number of datapoints and
        the number of derivatives at the edges. Specifically, ``nt - n`` must
        equal ``len(deriv_l) + len(deriv_r)``.
    bc_type : 2-tuple or None
        Boundary conditions.
        Default is None, which means choosing the boundary conditions
        automatically. Otherwise, it must be a length-two tuple where the first
        element sets the boundary conditions at ``x[0]`` and the second
        element sets the boundary conditions at ``x[-1]``. Each of these must
        be an iterable of pairs ``(order, value)`` which gives the values of
        derivatives of specified orders at the given edge of the interpolation
        interval.
        Alternatively, the following string aliases are recognized:
    
        * ``""clamped""``: The first derivatives at the ends are zero. This is
           equivalent to ``bc_type=((1, 0.0), (1, 0.0))``.
        * ``""natural""``: The second derivatives at ends are zero. This is
          equivalent to ``bc_type=((2, 0.0), (2, 0.0))``.
        * ``""not-a-knot""`` (default): The first and second segments are the same
          polynomial. This is equivalent to having ``bc_type=None``.
    
    axis : int, optional
        Interpolation axis. Default is 0.
    check_finite : bool, optional
        Whether to check that the input arrays contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default is True.
    
    Returns
    -------
    b : a BSpline object of the degree ``k`` and with knots ``t``.
    
    Examples
    --------
    
    Use cubic interpolation on Chebyshev nodes:
    
    >>> def cheb_nodes(N):
    ...     jj = 2.*np.arange(N) + 1
    ...     x = np.cos(np.pi * jj / 2 / N)[::-1]
    ...     return x
    
    >>> x = cheb_nodes(20)
    >>> y = np.sqrt(1 - x**2)
    
    >>> from scipy.interpolate import BSpline, make_interp_spline
    >>> b = make_interp_spline(x, y)
    >>> np.allclose(b(x), y)
    True
    
    Note that the default is a cubic spline with a not-a-knot boundary condition
    
    >>> b.k
    3
    
    Here we use a 'natural' spline, with zero 2nd derivatives at edges:
    
    >>> l, r = [(2, 0.0)], [(2, 0.0)]
    >>> b_n = make_interp_spline(x, y, bc_type=(l, r))  # or, bc_type=""natural""
    >>> np.allclose(b_n(x), y)
    True
    >>> x0, x1 = x[0], x[-1]
    >>> np.allclose([b_n(x0, 2), b_n(x1, 2)], [0, 0])
    True
    
    Interpolation of parametric curves is also supported. As an example, we
    compute a discretization of a snail curve in polar coordinates
    
    >>> phi = np.linspace(0, 2.*np.pi, 40)
    >>> r = 0.3 + np.cos(phi)
    >>> x, y = r*np.cos(phi), r*np.sin(phi)  # convert to Cartesian coordinates
    
    Build an interpolating curve, parameterizing it by the angle
    
    >>> from scipy.interpolate import make_interp_spline
    >>> spl = make_interp_spline(phi, np.c_[x, y])
    
    Evaluate the interpolant on a finer grid (note that we transpose the result
    to unpack it into a pair of x- and y-arrays)
    
    >>> phi_new = np.linspace(0, 2.*np.pi, 100)
    >>> x_new, y_new = spl(phi_new).T
    
    Plot the result
    
    >>> import matplotlib.pyplot as plt
    >>> plt.plot(x, y, 'o')
    >>> plt.plot(x_new, y_new, '-')
    >>> plt.show()
    
    See Also
    --------
    BSpline : base class representing the B-spline objects
    CubicSpline : a cubic spline in the polynomial basis
    make_lsq_spline : a similar factory function for spline fitting
    UnivariateSpline : a wrapper over FITPACK spline fitting routines
    splrep : a wrapper over FITPACK spline fitting routines
",function,"('x', 'y', 'k', 't', 'bc_type', 'axis', 'check_finite')","(nan, nan, 3, None, None, 0, True)","(nan, nan, 'int', 'NoneType', 'NoneType', 'int', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, y, k=3, t=None, bc_type=None, axis=0, check_finite=True)',)"
scipy,1.1.0,scipy.interpolate._bsplines.make_lsq_spline,interpolate._bsplines,make_lsq_spline,"Python Library Documentation: function make_lsq_spline in module scipy.interpolate._bsplines

make_lsq_spline(x, y, t, k=3, w=None, axis=0, check_finite=True)
    Compute the (coefficients of) an LSQ B-spline.
    
    The result is a linear combination
    
    .. math::
    
            S(x) = \sum_j c_j B_j(x; t)
    
    of the B-spline basis elements, :math:`B_j(x; t)`, which minimizes
    
    .. math::
    
        \sum_{j} \left( w_j \times (S(x_j) - y_j) \right)^2
    
    Parameters
    ----------
    x : array_like, shape (m,)
        Abscissas.
    y : array_like, shape (m, ...)
        Ordinates.
    t : array_like, shape (n + k + 1,).
        Knots.
        Knots and data points must satisfy Schoenberg-Whitney conditions.
    k : int, optional
        B-spline degree. Default is cubic, k=3.
    w : array_like, shape (n,), optional
        Weights for spline fitting. Must be positive. If ``None``,
        then weights are all equal.
        Default is ``None``.
    axis : int, optional
        Interpolation axis. Default is zero.
    check_finite : bool, optional
        Whether to check that the input arrays contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default is True.
    
    Returns
    -------
    b : a BSpline object of the degree `k` with knots `t`.
    
    Notes
    -----
    
    The number of data points must be larger than the spline degree `k`.
    
    Knots `t` must satisfy the Schoenberg-Whitney conditions,
    i.e., there must be a subset of data points ``x[j]`` such that
    ``t[j] < x[j] < t[j+k+1]``, for ``j=0, 1,...,n-k-2``.
    
    Examples
    --------
    Generate some noisy data:
    
    >>> x = np.linspace(-3, 3, 50)
    >>> y = np.exp(-x**2) + 0.1 * np.random.randn(50)
    
    Now fit a smoothing cubic spline with a pre-defined internal knots.
    Here we make the knot vector (k+1)-regular by adding boundary knots:
    
    >>> from scipy.interpolate import make_lsq_spline, BSpline
    >>> t = [-1, 0, 1]
    >>> k = 3
    >>> t = np.r_[(x[0],)*(k+1),
    ...           t,
    ...           (x[-1],)*(k+1)]
    >>> spl = make_lsq_spline(x, y, t, k)
    
    For comparison, we also construct an interpolating spline for the same
    set of data:
    
    >>> from scipy.interpolate import make_interp_spline
    >>> spl_i = make_interp_spline(x, y)
    
    Plot both:
    
    >>> import matplotlib.pyplot as plt
    >>> xs = np.linspace(-3, 3, 100)
    >>> plt.plot(x, y, 'ro', ms=5)
    >>> plt.plot(xs, spl(xs), 'g-', lw=3, label='LSQ spline')
    >>> plt.plot(xs, spl_i(xs), 'b-', lw=3, alpha=0.7, label='interp spline')
    >>> plt.legend(loc='best')
    >>> plt.show()
    
    **NaN handling**: If the input arrays contain ``nan`` values, the result is
    not useful since the underlying spline fitting routines cannot deal with
    ``nan``. A workaround is to use zero weights for not-a-number data points:
    
    >>> y[8] = np.nan
    >>> w = np.isnan(y)
    >>> y[w] = 0.
    >>> tck = make_lsq_spline(x, y, t, w=~w)
    
    Notice the need to replace a ``nan`` by a numerical value (precise value
    does not matter as long as the corresponding weight is zero.)
    
    See Also
    --------
    BSpline : base class representing the B-spline objects
    make_interp_spline : a similar factory function for interpolating splines
    LSQUnivariateSpline : a FITPACK-based spline fitting routine
    splrep : a FITPACK-based fitting routine
",function,"('(x, y, t, k=3, w=None, axis=0, check_finite=True)',)",scipy,1.1.0,scipy.interpolate._bsplines.make_lsq_spline,interpolate._bsplines,make_lsq_spline,"Python Library Documentation: function make_lsq_spline in module scipy.interpolate._bsplines

make_lsq_spline(x, y, t, k=3, w=None, axis=0, check_finite=True)
    Compute the (coefficients of) an LSQ B-spline.
    
    The result is a linear combination
    
    .. math::
    
            S(x) = \sum_j c_j B_j(x; t)
    
    of the B-spline basis elements, :math:`B_j(x; t)`, which minimizes
    
    .. math::
    
        \sum_{j} \left( w_j \times (S(x_j) - y_j) \right)^2
    
    Parameters
    ----------
    x : array_like, shape (m,)
        Abscissas.
    y : array_like, shape (m, ...)
        Ordinates.
    t : array_like, shape (n + k + 1,).
        Knots.
        Knots and data points must satisfy Schoenberg-Whitney conditions.
    k : int, optional
        B-spline degree. Default is cubic, k=3.
    w : array_like, shape (n,), optional
        Weights for spline fitting. Must be positive. If ``None``,
        then weights are all equal.
        Default is ``None``.
    axis : int, optional
        Interpolation axis. Default is zero.
    check_finite : bool, optional
        Whether to check that the input arrays contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default is True.
    
    Returns
    -------
    b : a BSpline object of the degree `k` with knots `t`.
    
    Notes
    -----
    
    The number of data points must be larger than the spline degree `k`.
    
    Knots `t` must satisfy the Schoenberg-Whitney conditions,
    i.e., there must be a subset of data points ``x[j]`` such that
    ``t[j] < x[j] < t[j+k+1]``, for ``j=0, 1,...,n-k-2``.
    
    Examples
    --------
    Generate some noisy data:
    
    >>> x = np.linspace(-3, 3, 50)
    >>> y = np.exp(-x**2) + 0.1 * np.random.randn(50)
    
    Now fit a smoothing cubic spline with a pre-defined internal knots.
    Here we make the knot vector (k+1)-regular by adding boundary knots:
    
    >>> from scipy.interpolate import make_lsq_spline, BSpline
    >>> t = [-1, 0, 1]
    >>> k = 3
    >>> t = np.r_[(x[0],)*(k+1),
    ...           t,
    ...           (x[-1],)*(k+1)]
    >>> spl = make_lsq_spline(x, y, t, k)
    
    For comparison, we also construct an interpolating spline for the same
    set of data:
    
    >>> from scipy.interpolate import make_interp_spline
    >>> spl_i = make_interp_spline(x, y)
    
    Plot both:
    
    >>> import matplotlib.pyplot as plt
    >>> xs = np.linspace(-3, 3, 100)
    >>> plt.plot(x, y, 'ro', ms=5)
    >>> plt.plot(xs, spl(xs), 'g-', lw=3, label='LSQ spline')
    >>> plt.plot(xs, spl_i(xs), 'b-', lw=3, alpha=0.7, label='interp spline')
    >>> plt.legend(loc='best')
    >>> plt.show()
    
    **NaN handling**: If the input arrays contain ``nan`` values, the result is
    not useful since the underlying spline fitting routines cannot deal with
    ``nan``. A workaround is to use zero weights for not-a-number data points:
    
    >>> y[8] = np.nan
    >>> w = np.isnan(y)
    >>> y[w] = 0.
    >>> tck = make_lsq_spline(x, y, t, w=~w)
    
    Notice the need to replace a ``nan`` by a numerical value (precise value
    does not matter as long as the corresponding weight is zero.)
    
    See Also
    --------
    BSpline : base class representing the B-spline objects
    make_interp_spline : a similar factory function for interpolating splines
    LSQUnivariateSpline : a FITPACK-based spline fitting routine
    splrep : a FITPACK-based fitting routine
",function,"('x', 'y', 't', 'k', 'w', 'axis', 'check_finite')","(nan, nan, nan, 3, None, 0, True)","(nan, nan, nan, 'int', 'NoneType', 'int', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, y, t, k=3, w=None, axis=0, check_finite=True)',)"
scipy,1.1.0,scipy.interpolate._bsplines.prod,interpolate._bsplines,prod,"Python Library Documentation: function prod in module scipy.interpolate._bsplines

prod(x)
    Product of a list of numbers; ~40x faster vs np.prod for Python tuples
",function,"('(x)',)",scipy,1.1.0,scipy.interpolate._bsplines.prod,interpolate._bsplines,prod,"Python Library Documentation: function prod in module scipy.interpolate._bsplines

prod(x)
    Product of a list of numbers; ~40x faster vs np.prod for Python tuples
",function,"('x',)","(nan,)","(nan,)","('arg_info',)","('(x)',)"
scipy,1.1.0,scipy.interpolate._cubic.Akima1DInterpolator,interpolate._cubic,Akima1DInterpolator,"Python Library Documentation: class Akima1DInterpolator in module scipy.interpolate._cubic

class Akima1DInterpolator(scipy.interpolate.interpolate.PPoly)
 |  Akima interpolator
 |  
 |  Fit piecewise cubic polynomials, given vectors x and y. The interpolation
 |  method by Akima uses a continuously differentiable sub-spline built from
 |  piecewise cubic polynomials. The resultant curve passes through the given
 |  data points and will appear smooth and natural.
 |  
 |  Parameters
 |  ----------
 |  x : ndarray, shape (m, )
 |      1-D array of monotonically increasing real values.
 |  y : ndarray, shape (m, ...)
 |      N-D array of real values. The length of `y` along the first axis must
 |      be equal to the length of `x`.
 |  axis : int, optional
 |      Specifies the axis of `y` along which to interpolate. Interpolation
 |      defaults to the first axis of `y`.
 |  
 |  Methods
 |  -------
 |  __call__
 |  derivative
 |  antiderivative
 |  roots
 |  
 |  See Also
 |  --------
 |  PchipInterpolator
 |  CubicSpline
 |  PPoly
 |  
 |  Notes
 |  -----
 |  .. versionadded:: 0.14
 |  
 |  Use only for precise data, as the fitted curve passes through the given
 |  points exactly. This routine is useful for plotting a pleasingly smooth
 |  curve through a few given points for purposes of plotting.
 |  
 |  References
 |  ----------
 |  [1] A new method of interpolation and smooth curve fitting based
 |      on local procedures. Hiroshi Akima, J. ACM, October 1970, 17(4),
 |      589-602.
 |  
 |  Method resolution order:
 |      Akima1DInterpolator
 |      scipy.interpolate.interpolate.PPoly
 |      scipy.interpolate.interpolate._PPolyBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, x, y, axis=0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  extend(self, c, x, right=True)
 |      Add additional breakpoints and coefficients to the polynomial.
 |      
 |      Parameters
 |      ----------
 |      c : ndarray, size (k, m, ...)
 |          Additional coefficients for polynomials in intervals. Note that
 |          the first additional interval will be formed using one of the
 |          `self.x` end points.
 |      x : ndarray, size (m,)
 |          Additional breakpoints. Must be sorted in the same order as
 |          `self.x` and either to the right or to the left of the current
 |          breakpoints.
 |      right
 |          Deprecated argument. Has no effect.
 |      
 |          .. deprecated:: 0.19
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_bernstein_basis(bp, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial in the power basis
 |      from a polynomial in Bernstein basis.
 |      
 |      Parameters
 |      ----------
 |      bp : BPoly
 |          A Bernstein basis polynomial, as created by BPoly
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |  
 |  from_spline(tck, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial from a spline
 |      
 |      Parameters
 |      ----------
 |      tck
 |          A spline, as returned by `splrep` or a BSpline object.
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.interpolate.interpolate.PPoly:
 |  
 |  antiderivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the antiderivative.
 |      
 |      Antiderivative is also the indefinite integral of the function,
 |      and derivative is its inverse operation.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of antiderivative to evaluate. Default is 1, i.e. compute
 |          the first integral. If negative, the derivative is returned.
 |      
 |      Returns
 |      -------
 |      pp : PPoly
 |          Piecewise polynomial of order k2 = k + n representing
 |          the antiderivative of this polynomial.
 |      
 |      Notes
 |      -----
 |      The antiderivative returned by this function is continuous and
 |      continuously differentiable to order n-1, up to floating point
 |      rounding error.
 |      
 |      If antiderivative is computed and ``self.extrapolate='periodic'``,
 |      it will be set to False for the returned instance. This is done because
 |      the antiderivative is no longer periodic and its correct evaluation
 |      outside of the initially given x interval is difficult.
 |  
 |  derivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the derivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of derivative to evaluate. Default is 1, i.e. compute the
 |          first derivative. If negative, the antiderivative is returned.
 |      
 |      Returns
 |      -------
 |      pp : PPoly
 |          Piecewise polynomial of order k2 = k - n representing the derivative
 |          of this polynomial.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  integrate(self, a, b, extrapolate=None)
 |      Compute a definite integral over a piecewise polynomial.
 |      
 |      Parameters
 |      ----------
 |      a : float
 |          Lower integration bound
 |      b : float
 |          Upper integration bound
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      ig : array_like
 |          Definite integral of the piecewise polynomial over [a, b]
 |  
 |  roots(self, discontinuity=True, extrapolate=None)
 |      Find real roots of the the piecewise polynomial.
 |      
 |      Parameters
 |      ----------
 |      discontinuity : bool, optional
 |          Whether to report sign changes across discontinuities at
 |          breakpoints as roots.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to return roots from the polynomial
 |          extrapolated based on first and last intervals, 'periodic' works
 |          the same as False. If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      roots : ndarray
 |          Roots of the polynomial(s).
 |      
 |          If the PPoly object describes multiple polynomials, the
 |          return value is an object array whose each element is an
 |          ndarray containing the roots.
 |      
 |      See Also
 |      --------
 |      PPoly.solve
 |  
 |  solve(self, y=0.0, discontinuity=True, extrapolate=None)
 |      Find real solutions of the the equation ``pp(x) == y``.
 |      
 |      Parameters
 |      ----------
 |      y : float, optional
 |          Right-hand side. Default is zero.
 |      discontinuity : bool, optional
 |          Whether to report sign changes across discontinuities at
 |          breakpoints as roots.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to return roots from the polynomial
 |          extrapolated based on first and last intervals, 'periodic' works
 |          the same as False. If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      roots : ndarray
 |          Roots of the polynomial(s).
 |      
 |          If the PPoly object describes multiple polynomials, the
 |          return value is an object array whose each element is an
 |          ndarray containing the roots.
 |      
 |      Notes
 |      -----
 |      This routine works only on real-valued polynomials.
 |      
 |      If the piecewise polynomial contains sections that are
 |      identically zero, the root list will contain the start point
 |      of the corresponding interval, followed by a ``nan`` value.
 |      
 |      If the polynomial is discontinuous across a breakpoint, and
 |      there is a sign change across the breakpoint, this is reported
 |      if the `discont` parameter is True.
 |      
 |      Examples
 |      --------
 |      
 |      Finding roots of ``[x**2 - 1, (x - 1)**2]`` defined on intervals
 |      ``[-2, 1], [1, 2]``:
 |      
 |      >>> from scipy.interpolate import PPoly
 |      >>> pp = PPoly(np.array([[1, -4, 3], [1, 0, 0]]).T, [-2, 1, 2])
 |      >>> pp.roots()
 |      array([-1.,  1.])
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.interpolate.interpolate.PPoly:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.interpolate.interpolate._PPolyBase:
 |  
 |  __call__(self, x, nu=0, extrapolate=None)
 |      Evaluate the piecewise polynomial or its derivative.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      nu : int, optional
 |          Order of derivative to evaluate. Must be non-negative.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  ----------------------------------------------------------------------
 |  Class methods inherited from scipy.interpolate.interpolate._PPolyBase:
 |  
 |  construct_fast(c, x, extrapolate=None, axis=0) from builtins.type
 |      Construct the piecewise polynomial without making checks.
 |      
 |      Takes the same parameters as the constructor. Input arguments
 |      `c` and `x` must be arrays of the correct shape and type.  The
 |      `c` array can only be of dtypes float and complex, and `x`
 |      array must have dtype float.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.interpolate.interpolate._PPolyBase:
 |  
 |  axis
 |  
 |  c
 |  
 |  extrapolate
 |  
 |  x
",class,"('(self, x, y, axis=0)',)",scipy,1.1.0,scipy.interpolate._cubic.Akima1DInterpolator,interpolate._cubic,Akima1DInterpolator,"Python Library Documentation: class Akima1DInterpolator in module scipy.interpolate._cubic

class Akima1DInterpolator(scipy.interpolate.interpolate.PPoly)
 |  Akima interpolator
 |  
 |  Fit piecewise cubic polynomials, given vectors x and y. The interpolation
 |  method by Akima uses a continuously differentiable sub-spline built from
 |  piecewise cubic polynomials. The resultant curve passes through the given
 |  data points and will appear smooth and natural.
 |  
 |  Parameters
 |  ----------
 |  x : ndarray, shape (m, )
 |      1-D array of monotonically increasing real values.
 |  y : ndarray, shape (m, ...)
 |      N-D array of real values. The length of `y` along the first axis must
 |      be equal to the length of `x`.
 |  axis : int, optional
 |      Specifies the axis of `y` along which to interpolate. Interpolation
 |      defaults to the first axis of `y`.
 |  
 |  Methods
 |  -------
 |  __call__
 |  derivative
 |  antiderivative
 |  roots
 |  
 |  See Also
 |  --------
 |  PchipInterpolator
 |  CubicSpline
 |  PPoly
 |  
 |  Notes
 |  -----
 |  .. versionadded:: 0.14
 |  
 |  Use only for precise data, as the fitted curve passes through the given
 |  points exactly. This routine is useful for plotting a pleasingly smooth
 |  curve through a few given points for purposes of plotting.
 |  
 |  References
 |  ----------
 |  [1] A new method of interpolation and smooth curve fitting based
 |      on local procedures. Hiroshi Akima, J. ACM, October 1970, 17(4),
 |      589-602.
 |  
 |  Method resolution order:
 |      Akima1DInterpolator
 |      scipy.interpolate.interpolate.PPoly
 |      scipy.interpolate.interpolate._PPolyBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, x, y, axis=0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  extend(self, c, x, right=True)
 |      Add additional breakpoints and coefficients to the polynomial.
 |      
 |      Parameters
 |      ----------
 |      c : ndarray, size (k, m, ...)
 |          Additional coefficients for polynomials in intervals. Note that
 |          the first additional interval will be formed using one of the
 |          `self.x` end points.
 |      x : ndarray, size (m,)
 |          Additional breakpoints. Must be sorted in the same order as
 |          `self.x` and either to the right or to the left of the current
 |          breakpoints.
 |      right
 |          Deprecated argument. Has no effect.
 |      
 |          .. deprecated:: 0.19
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_bernstein_basis(bp, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial in the power basis
 |      from a polynomial in Bernstein basis.
 |      
 |      Parameters
 |      ----------
 |      bp : BPoly
 |          A Bernstein basis polynomial, as created by BPoly
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |  
 |  from_spline(tck, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial from a spline
 |      
 |      Parameters
 |      ----------
 |      tck
 |          A spline, as returned by `splrep` or a BSpline object.
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.interpolate.interpolate.PPoly:
 |  
 |  antiderivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the antiderivative.
 |      
 |      Antiderivative is also the indefinite integral of the function,
 |      and derivative is its inverse operation.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of antiderivative to evaluate. Default is 1, i.e. compute
 |          the first integral. If negative, the derivative is returned.
 |      
 |      Returns
 |      -------
 |      pp : PPoly
 |          Piecewise polynomial of order k2 = k + n representing
 |          the antiderivative of this polynomial.
 |      
 |      Notes
 |      -----
 |      The antiderivative returned by this function is continuous and
 |      continuously differentiable to order n-1, up to floating point
 |      rounding error.
 |      
 |      If antiderivative is computed and ``self.extrapolate='periodic'``,
 |      it will be set to False for the returned instance. This is done because
 |      the antiderivative is no longer periodic and its correct evaluation
 |      outside of the initially given x interval is difficult.
 |  
 |  derivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the derivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of derivative to evaluate. Default is 1, i.e. compute the
 |          first derivative. If negative, the antiderivative is returned.
 |      
 |      Returns
 |      -------
 |      pp : PPoly
 |          Piecewise polynomial of order k2 = k - n representing the derivative
 |          of this polynomial.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  integrate(self, a, b, extrapolate=None)
 |      Compute a definite integral over a piecewise polynomial.
 |      
 |      Parameters
 |      ----------
 |      a : float
 |          Lower integration bound
 |      b : float
 |          Upper integration bound
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      ig : array_like
 |          Definite integral of the piecewise polynomial over [a, b]
 |  
 |  roots(self, discontinuity=True, extrapolate=None)
 |      Find real roots of the the piecewise polynomial.
 |      
 |      Parameters
 |      ----------
 |      discontinuity : bool, optional
 |          Whether to report sign changes across discontinuities at
 |          breakpoints as roots.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to return roots from the polynomial
 |          extrapolated based on first and last intervals, 'periodic' works
 |          the same as False. If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      roots : ndarray
 |          Roots of the polynomial(s).
 |      
 |          If the PPoly object describes multiple polynomials, the
 |          return value is an object array whose each element is an
 |          ndarray containing the roots.
 |      
 |      See Also
 |      --------
 |      PPoly.solve
 |  
 |  solve(self, y=0.0, discontinuity=True, extrapolate=None)
 |      Find real solutions of the the equation ``pp(x) == y``.
 |      
 |      Parameters
 |      ----------
 |      y : float, optional
 |          Right-hand side. Default is zero.
 |      discontinuity : bool, optional
 |          Whether to report sign changes across discontinuities at
 |          breakpoints as roots.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to return roots from the polynomial
 |          extrapolated based on first and last intervals, 'periodic' works
 |          the same as False. If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      roots : ndarray
 |          Roots of the polynomial(s).
 |      
 |          If the PPoly object describes multiple polynomials, the
 |          return value is an object array whose each element is an
 |          ndarray containing the roots.
 |      
 |      Notes
 |      -----
 |      This routine works only on real-valued polynomials.
 |      
 |      If the piecewise polynomial contains sections that are
 |      identically zero, the root list will contain the start point
 |      of the corresponding interval, followed by a ``nan`` value.
 |      
 |      If the polynomial is discontinuous across a breakpoint, and
 |      there is a sign change across the breakpoint, this is reported
 |      if the `discont` parameter is True.
 |      
 |      Examples
 |      --------
 |      
 |      Finding roots of ``[x**2 - 1, (x - 1)**2]`` defined on intervals
 |      ``[-2, 1], [1, 2]``:
 |      
 |      >>> from scipy.interpolate import PPoly
 |      >>> pp = PPoly(np.array([[1, -4, 3], [1, 0, 0]]).T, [-2, 1, 2])
 |      >>> pp.roots()
 |      array([-1.,  1.])
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.interpolate.interpolate.PPoly:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.interpolate.interpolate._PPolyBase:
 |  
 |  __call__(self, x, nu=0, extrapolate=None)
 |      Evaluate the piecewise polynomial or its derivative.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      nu : int, optional
 |          Order of derivative to evaluate. Must be non-negative.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  ----------------------------------------------------------------------
 |  Class methods inherited from scipy.interpolate.interpolate._PPolyBase:
 |  
 |  construct_fast(c, x, extrapolate=None, axis=0) from builtins.type
 |      Construct the piecewise polynomial without making checks.
 |      
 |      Takes the same parameters as the constructor. Input arguments
 |      `c` and `x` must be arrays of the correct shape and type.  The
 |      `c` array can only be of dtypes float and complex, and `x`
 |      array must have dtype float.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.interpolate.interpolate._PPolyBase:
 |  
 |  axis
 |  
 |  c
 |  
 |  extrapolate
 |  
 |  x
",class,"('self', 'x', 'y', 'axis')","(nan, nan, nan, 0)","(nan, nan, nan, 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, x, y, axis=0)',)"
scipy,1.1.0,scipy.interpolate._cubic.Akima1DInterpolator.construct_fast,interpolate._cubic.Akima1DInterpolator,construct_fast,"Python Library Documentation: method construct_fast in module scipy.interpolate.interpolate

construct_fast(c, x, extrapolate=None, axis=0) method of builtins.type instance
    Construct the piecewise polynomial without making checks.
    
    Takes the same parameters as the constructor. Input arguments
    `c` and `x` must be arrays of the correct shape and type.  The
    `c` array can only be of dtypes float and complex, and `x`
    array must have dtype float.
",method,"('(c, x, extrapolate=None, axis=0)',)",scipy,1.1.0,scipy.interpolate._cubic.Akima1DInterpolator.construct_fast,interpolate._cubic.Akima1DInterpolator,construct_fast,"Python Library Documentation: method construct_fast in module scipy.interpolate.interpolate

construct_fast(c, x, extrapolate=None, axis=0) method of builtins.type instance
    Construct the piecewise polynomial without making checks.
    
    Takes the same parameters as the constructor. Input arguments
    `c` and `x` must be arrays of the correct shape and type.  The
    `c` array can only be of dtypes float and complex, and `x`
    array must have dtype float.
",method,"('cls', 'c', 'x', 'extrapolate', 'axis')","(nan, nan, nan, None, 0)","(nan, nan, nan, 'NoneType', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(c, x, extrapolate=None, axis=0)',)"
scipy,1.1.0,scipy.interpolate._cubic.Akima1DInterpolator.from_bernstein_basis,interpolate._cubic.Akima1DInterpolator,from_bernstein_basis,"Python Library Documentation: method from_bernstein_basis in module scipy.interpolate._cubic

from_bernstein_basis(bp, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial in the power basis
    from a polynomial in Bernstein basis.
    
    Parameters
    ----------
    bp : BPoly
        A Bernstein basis polynomial, as created by BPoly
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
",method,"('(bp, extrapolate=None)',)",scipy,1.1.0,scipy.interpolate._cubic.Akima1DInterpolator.from_bernstein_basis,interpolate._cubic.Akima1DInterpolator,from_bernstein_basis,"Python Library Documentation: method from_bernstein_basis in module scipy.interpolate._cubic

from_bernstein_basis(bp, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial in the power basis
    from a polynomial in Bernstein basis.
    
    Parameters
    ----------
    bp : BPoly
        A Bernstein basis polynomial, as created by BPoly
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
",method,"('cls', 'bp', 'extrapolate')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(bp, extrapolate=None)',)"
scipy,1.1.0,scipy.interpolate._cubic.Akima1DInterpolator.from_spline,interpolate._cubic.Akima1DInterpolator,from_spline,"Python Library Documentation: method from_spline in module scipy.interpolate._cubic

from_spline(tck, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial from a spline
    
    Parameters
    ----------
    tck
        A spline, as returned by `splrep` or a BSpline object.
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
",method,"('(tck, extrapolate=None)',)",scipy,1.1.0,scipy.interpolate._cubic.Akima1DInterpolator.from_spline,interpolate._cubic.Akima1DInterpolator,from_spline,"Python Library Documentation: method from_spline in module scipy.interpolate._cubic

from_spline(tck, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial from a spline
    
    Parameters
    ----------
    tck
        A spline, as returned by `splrep` or a BSpline object.
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
",method,"('cls', 'tck', 'extrapolate')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(tck, extrapolate=None)',)"
scipy,1.1.0,scipy.interpolate._cubic.BPoly,interpolate._cubic,BPoly,"Python Library Documentation: class BPoly in module scipy.interpolate.interpolate

class BPoly(_PPolyBase)
 |  Piecewise polynomial in terms of coefficients and breakpoints.
 |  
 |  The polynomial between ``x[i]`` and ``x[i + 1]`` is written in the
 |  Bernstein polynomial basis::
 |  
 |      S = sum(c[a, i] * b(a, k; x) for a in range(k+1)),
 |  
 |  where ``k`` is the degree of the polynomial, and::
 |  
 |      b(a, k; x) = binom(k, a) * t**a * (1 - t)**(k - a),
 |  
 |  with ``t = (x - x[i]) / (x[i+1] - x[i])`` and ``binom`` is the binomial
 |  coefficient.
 |  
 |  Parameters
 |  ----------
 |  c : ndarray, shape (k, m, ...)
 |      Polynomial coefficients, order `k` and `m` intervals
 |  x : ndarray, shape (m+1,)
 |      Polynomial breakpoints. Must be sorted in either increasing or
 |      decreasing order.
 |  extrapolate : bool, optional
 |      If bool, determines whether to extrapolate to out-of-bounds points
 |      based on first and last intervals, or to return NaNs. If 'periodic',
 |      periodic extrapolation is used. Default is True.
 |  axis : int, optional
 |      Interpolation axis. Default is zero.
 |  
 |  Attributes
 |  ----------
 |  x : ndarray
 |      Breakpoints.
 |  c : ndarray
 |      Coefficients of the polynomials. They are reshaped
 |      to a 3-dimensional array with the last dimension representing
 |      the trailing dimensions of the original coefficient array.
 |  axis : int
 |      Interpolation axis.
 |  
 |  Methods
 |  -------
 |  __call__
 |  extend
 |  derivative
 |  antiderivative
 |  integrate
 |  construct_fast
 |  from_power_basis
 |  from_derivatives
 |  
 |  See also
 |  --------
 |  PPoly : piecewise polynomials in the power basis
 |  
 |  Notes
 |  -----
 |  Properties of Bernstein polynomials are well documented in the literature.
 |  Here's a non-exhaustive list:
 |  
 |  .. [1] http://en.wikipedia.org/wiki/Bernstein_polynomial
 |  
 |  .. [2] Kenneth I. Joy, Bernstein polynomials,
 |    http://www.idav.ucdavis.edu/education/CAGDNotes/Bernstein-Polynomials.pdf
 |  
 |  .. [3] E. H. Doha, A. H. Bhrawy, and M. A. Saker, Boundary Value Problems,
 |       vol 2011, article ID 829546, :doi:`10.1155/2011/829543`.
 |  
 |  Examples
 |  --------
 |  >>> from scipy.interpolate import BPoly
 |  >>> x = [0, 1]
 |  >>> c = [[1], [2], [3]]
 |  >>> bp = BPoly(c, x)
 |  
 |  This creates a 2nd order polynomial
 |  
 |  .. math::
 |  
 |      B(x) = 1 \times b_{0, 2}(x) + 2 \times b_{1, 2}(x) + 3 \times b_{2, 2}(x) \\
 |           = 1 \times (1-x)^2 + 2 \times 2 x (1 - x) + 3 \times x^2
 |  
 |  Method resolution order:
 |      BPoly
 |      _PPolyBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  antiderivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the antiderivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of antiderivative to evaluate. Default is 1, i.e. compute
 |          the first integral. If negative, the derivative is returned.
 |      
 |      Returns
 |      -------
 |      bp : BPoly
 |          Piecewise polynomial of order k + nu representing the
 |          antiderivative of this polynomial.
 |      
 |      Notes
 |      -----
 |      If antiderivative is computed and ``self.extrapolate='periodic'``,
 |      it will be set to False for the returned instance. This is done because
 |      the antiderivative is no longer periodic and its correct evaluation
 |      outside of the initially given x interval is difficult.
 |  
 |  derivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the derivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of derivative to evaluate. Default is 1, i.e. compute the
 |          first derivative. If negative, the antiderivative is returned.
 |      
 |      Returns
 |      -------
 |      bp : BPoly
 |          Piecewise polynomial of order k - nu representing the derivative of
 |          this polynomial.
 |  
 |  extend(self, c, x, right=None)
 |      Add additional breakpoints and coefficients to the polynomial.
 |      
 |      Parameters
 |      ----------
 |      c : ndarray, size (k, m, ...)
 |          Additional coefficients for polynomials in intervals. Note that
 |          the first additional interval will be formed using one of the
 |          `self.x` end points.
 |      x : ndarray, size (m,)
 |          Additional breakpoints. Must be sorted in the same order as
 |          `self.x` and either to the right or to the left of the current
 |          breakpoints.
 |      right
 |          Deprecated argument. Has no effect.
 |      
 |          .. deprecated:: 0.19
 |  
 |  integrate(self, a, b, extrapolate=None)
 |      Compute a definite integral over a piecewise polynomial.
 |      
 |      Parameters
 |      ----------
 |      a : float
 |          Lower integration bound
 |      b : float
 |          Upper integration bound
 |      extrapolate : {bool, 'periodic', None}, optional
 |          Whether to extrapolate to out-of-bounds points based on first
 |          and last intervals, or to return NaNs. If 'periodic', periodic
 |          extrapolation is used. If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      array_like
 |          Definite integral of the piecewise polynomial over [a, b]
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_derivatives(xi, yi, orders=None, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial in the Bernstein basis,
 |      compatible with the specified values and derivatives at breakpoints.
 |      
 |      Parameters
 |      ----------
 |      xi : array_like
 |          sorted 1D array of x-coordinates
 |      yi : array_like or list of array_likes
 |          ``yi[i][j]`` is the ``j``-th derivative known at ``xi[i]``
 |      orders : None or int or array_like of ints. Default: None.
 |          Specifies the degree of local polynomials. If not None, some
 |          derivatives are ignored.
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |      
 |      Notes
 |      -----
 |      If ``k`` derivatives are specified at a breakpoint ``x``, the
 |      constructed polynomial is exactly ``k`` times continuously
 |      differentiable at ``x``, unless the ``order`` is provided explicitly.
 |      In the latter case, the smoothness of the polynomial at
 |      the breakpoint is controlled by the ``order``.
 |      
 |      Deduces the number of derivatives to match at each end
 |      from ``order`` and the number of derivatives available. If
 |      possible it uses the same number of derivatives from
 |      each end; if the number is odd it tries to take the
 |      extra one from y2. In any case if not enough derivatives
 |      are available at one end or another it draws enough to
 |      make up the total from the other end.
 |      
 |      If the order is too high and not enough derivatives are available,
 |      an exception is raised.
 |      
 |      Examples
 |      --------
 |      
 |      >>> from scipy.interpolate import BPoly
 |      >>> BPoly.from_derivatives([0, 1], [[1, 2], [3, 4]])
 |      
 |      Creates a polynomial `f(x)` of degree 3, defined on `[0, 1]`
 |      such that `f(0) = 1, df/dx(0) = 2, f(1) = 3, df/dx(1) = 4`
 |      
 |      >>> BPoly.from_derivatives([0, 1, 2], [[0, 1], [0], [2]])
 |      
 |      Creates a piecewise polynomial `f(x)`, such that
 |      `f(0) = f(1) = 0`, `f(2) = 2`, and `df/dx(0) = 1`.
 |      Based on the number of derivatives provided, the order of the
 |      local polynomials is 2 on `[0, 1]` and 1 on `[1, 2]`.
 |      Notice that no restriction is imposed on the derivatives at
 |      `x = 1` and `x = 2`.
 |      
 |      Indeed, the explicit form of the polynomial is::
 |      
 |          f(x) = | x * (1 - x),  0 <= x < 1
 |                 | 2 * (x - 1),  1 <= x <= 2
 |      
 |      So that f'(1-0) = -1 and f'(1+0) = 2
 |  
 |  from_power_basis(pp, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial in Bernstein basis
 |      from a power basis polynomial.
 |      
 |      Parameters
 |      ----------
 |      pp : PPoly
 |          A piecewise polynomial in the power basis
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _PPolyBase:
 |  
 |  __call__(self, x, nu=0, extrapolate=None)
 |      Evaluate the piecewise polynomial or its derivative.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      nu : int, optional
 |          Order of derivative to evaluate. Must be non-negative.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  __init__(self, c, x, extrapolate=None, axis=0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Class methods inherited from _PPolyBase:
 |  
 |  construct_fast(c, x, extrapolate=None, axis=0) from builtins.type
 |      Construct the piecewise polynomial without making checks.
 |      
 |      Takes the same parameters as the constructor. Input arguments
 |      `c` and `x` must be arrays of the correct shape and type.  The
 |      `c` array can only be of dtypes float and complex, and `x`
 |      array must have dtype float.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _PPolyBase:
 |  
 |  axis
 |  
 |  c
 |  
 |  extrapolate
 |  
 |  x
",class,"('(self, c, x, extrapolate=None, axis=0)',)",scipy,1.1.0,scipy.interpolate._cubic.BPoly,interpolate._cubic,BPoly,"Python Library Documentation: class BPoly in module scipy.interpolate.interpolate

class BPoly(_PPolyBase)
 |  Piecewise polynomial in terms of coefficients and breakpoints.
 |  
 |  The polynomial between ``x[i]`` and ``x[i + 1]`` is written in the
 |  Bernstein polynomial basis::
 |  
 |      S = sum(c[a, i] * b(a, k; x) for a in range(k+1)),
 |  
 |  where ``k`` is the degree of the polynomial, and::
 |  
 |      b(a, k; x) = binom(k, a) * t**a * (1 - t)**(k - a),
 |  
 |  with ``t = (x - x[i]) / (x[i+1] - x[i])`` and ``binom`` is the binomial
 |  coefficient.
 |  
 |  Parameters
 |  ----------
 |  c : ndarray, shape (k, m, ...)
 |      Polynomial coefficients, order `k` and `m` intervals
 |  x : ndarray, shape (m+1,)
 |      Polynomial breakpoints. Must be sorted in either increasing or
 |      decreasing order.
 |  extrapolate : bool, optional
 |      If bool, determines whether to extrapolate to out-of-bounds points
 |      based on first and last intervals, or to return NaNs. If 'periodic',
 |      periodic extrapolation is used. Default is True.
 |  axis : int, optional
 |      Interpolation axis. Default is zero.
 |  
 |  Attributes
 |  ----------
 |  x : ndarray
 |      Breakpoints.
 |  c : ndarray
 |      Coefficients of the polynomials. They are reshaped
 |      to a 3-dimensional array with the last dimension representing
 |      the trailing dimensions of the original coefficient array.
 |  axis : int
 |      Interpolation axis.
 |  
 |  Methods
 |  -------
 |  __call__
 |  extend
 |  derivative
 |  antiderivative
 |  integrate
 |  construct_fast
 |  from_power_basis
 |  from_derivatives
 |  
 |  See also
 |  --------
 |  PPoly : piecewise polynomials in the power basis
 |  
 |  Notes
 |  -----
 |  Properties of Bernstein polynomials are well documented in the literature.
 |  Here's a non-exhaustive list:
 |  
 |  .. [1] http://en.wikipedia.org/wiki/Bernstein_polynomial
 |  
 |  .. [2] Kenneth I. Joy, Bernstein polynomials,
 |    http://www.idav.ucdavis.edu/education/CAGDNotes/Bernstein-Polynomials.pdf
 |  
 |  .. [3] E. H. Doha, A. H. Bhrawy, and M. A. Saker, Boundary Value Problems,
 |       vol 2011, article ID 829546, :doi:`10.1155/2011/829543`.
 |  
 |  Examples
 |  --------
 |  >>> from scipy.interpolate import BPoly
 |  >>> x = [0, 1]
 |  >>> c = [[1], [2], [3]]
 |  >>> bp = BPoly(c, x)
 |  
 |  This creates a 2nd order polynomial
 |  
 |  .. math::
 |  
 |      B(x) = 1 \times b_{0, 2}(x) + 2 \times b_{1, 2}(x) + 3 \times b_{2, 2}(x) \\
 |           = 1 \times (1-x)^2 + 2 \times 2 x (1 - x) + 3 \times x^2
 |  
 |  Method resolution order:
 |      BPoly
 |      _PPolyBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  antiderivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the antiderivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of antiderivative to evaluate. Default is 1, i.e. compute
 |          the first integral. If negative, the derivative is returned.
 |      
 |      Returns
 |      -------
 |      bp : BPoly
 |          Piecewise polynomial of order k + nu representing the
 |          antiderivative of this polynomial.
 |      
 |      Notes
 |      -----
 |      If antiderivative is computed and ``self.extrapolate='periodic'``,
 |      it will be set to False for the returned instance. This is done because
 |      the antiderivative is no longer periodic and its correct evaluation
 |      outside of the initially given x interval is difficult.
 |  
 |  derivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the derivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of derivative to evaluate. Default is 1, i.e. compute the
 |          first derivative. If negative, the antiderivative is returned.
 |      
 |      Returns
 |      -------
 |      bp : BPoly
 |          Piecewise polynomial of order k - nu representing the derivative of
 |          this polynomial.
 |  
 |  extend(self, c, x, right=None)
 |      Add additional breakpoints and coefficients to the polynomial.
 |      
 |      Parameters
 |      ----------
 |      c : ndarray, size (k, m, ...)
 |          Additional coefficients for polynomials in intervals. Note that
 |          the first additional interval will be formed using one of the
 |          `self.x` end points.
 |      x : ndarray, size (m,)
 |          Additional breakpoints. Must be sorted in the same order as
 |          `self.x` and either to the right or to the left of the current
 |          breakpoints.
 |      right
 |          Deprecated argument. Has no effect.
 |      
 |          .. deprecated:: 0.19
 |  
 |  integrate(self, a, b, extrapolate=None)
 |      Compute a definite integral over a piecewise polynomial.
 |      
 |      Parameters
 |      ----------
 |      a : float
 |          Lower integration bound
 |      b : float
 |          Upper integration bound
 |      extrapolate : {bool, 'periodic', None}, optional
 |          Whether to extrapolate to out-of-bounds points based on first
 |          and last intervals, or to return NaNs. If 'periodic', periodic
 |          extrapolation is used. If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      array_like
 |          Definite integral of the piecewise polynomial over [a, b]
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_derivatives(xi, yi, orders=None, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial in the Bernstein basis,
 |      compatible with the specified values and derivatives at breakpoints.
 |      
 |      Parameters
 |      ----------
 |      xi : array_like
 |          sorted 1D array of x-coordinates
 |      yi : array_like or list of array_likes
 |          ``yi[i][j]`` is the ``j``-th derivative known at ``xi[i]``
 |      orders : None or int or array_like of ints. Default: None.
 |          Specifies the degree of local polynomials. If not None, some
 |          derivatives are ignored.
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |      
 |      Notes
 |      -----
 |      If ``k`` derivatives are specified at a breakpoint ``x``, the
 |      constructed polynomial is exactly ``k`` times continuously
 |      differentiable at ``x``, unless the ``order`` is provided explicitly.
 |      In the latter case, the smoothness of the polynomial at
 |      the breakpoint is controlled by the ``order``.
 |      
 |      Deduces the number of derivatives to match at each end
 |      from ``order`` and the number of derivatives available. If
 |      possible it uses the same number of derivatives from
 |      each end; if the number is odd it tries to take the
 |      extra one from y2. In any case if not enough derivatives
 |      are available at one end or another it draws enough to
 |      make up the total from the other end.
 |      
 |      If the order is too high and not enough derivatives are available,
 |      an exception is raised.
 |      
 |      Examples
 |      --------
 |      
 |      >>> from scipy.interpolate import BPoly
 |      >>> BPoly.from_derivatives([0, 1], [[1, 2], [3, 4]])
 |      
 |      Creates a polynomial `f(x)` of degree 3, defined on `[0, 1]`
 |      such that `f(0) = 1, df/dx(0) = 2, f(1) = 3, df/dx(1) = 4`
 |      
 |      >>> BPoly.from_derivatives([0, 1, 2], [[0, 1], [0], [2]])
 |      
 |      Creates a piecewise polynomial `f(x)`, such that
 |      `f(0) = f(1) = 0`, `f(2) = 2`, and `df/dx(0) = 1`.
 |      Based on the number of derivatives provided, the order of the
 |      local polynomials is 2 on `[0, 1]` and 1 on `[1, 2]`.
 |      Notice that no restriction is imposed on the derivatives at
 |      `x = 1` and `x = 2`.
 |      
 |      Indeed, the explicit form of the polynomial is::
 |      
 |          f(x) = | x * (1 - x),  0 <= x < 1
 |                 | 2 * (x - 1),  1 <= x <= 2
 |      
 |      So that f'(1-0) = -1 and f'(1+0) = 2
 |  
 |  from_power_basis(pp, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial in Bernstein basis
 |      from a power basis polynomial.
 |      
 |      Parameters
 |      ----------
 |      pp : PPoly
 |          A piecewise polynomial in the power basis
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _PPolyBase:
 |  
 |  __call__(self, x, nu=0, extrapolate=None)
 |      Evaluate the piecewise polynomial or its derivative.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      nu : int, optional
 |          Order of derivative to evaluate. Must be non-negative.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  __init__(self, c, x, extrapolate=None, axis=0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Class methods inherited from _PPolyBase:
 |  
 |  construct_fast(c, x, extrapolate=None, axis=0) from builtins.type
 |      Construct the piecewise polynomial without making checks.
 |      
 |      Takes the same parameters as the constructor. Input arguments
 |      `c` and `x` must be arrays of the correct shape and type.  The
 |      `c` array can only be of dtypes float and complex, and `x`
 |      array must have dtype float.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _PPolyBase:
 |  
 |  axis
 |  
 |  c
 |  
 |  extrapolate
 |  
 |  x
",class,"('self', 'c', 'x', 'extrapolate', 'axis')","(nan, nan, nan, None, 0)","(nan, nan, nan, 'NoneType', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, c, x, extrapolate=None, axis=0)',)"
scipy,1.1.0,scipy.interpolate._cubic.BPoly.construct_fast,interpolate._cubic.BPoly,construct_fast,"Python Library Documentation: method construct_fast in module scipy.interpolate.interpolate

construct_fast(c, x, extrapolate=None, axis=0) method of builtins.type instance
    Construct the piecewise polynomial without making checks.
    
    Takes the same parameters as the constructor. Input arguments
    `c` and `x` must be arrays of the correct shape and type.  The
    `c` array can only be of dtypes float and complex, and `x`
    array must have dtype float.
",method,"('(c, x, extrapolate=None, axis=0)',)",scipy,1.1.0,scipy.interpolate._cubic.BPoly.construct_fast,interpolate._cubic.BPoly,construct_fast,"Python Library Documentation: method construct_fast in module scipy.interpolate.interpolate

construct_fast(c, x, extrapolate=None, axis=0) method of builtins.type instance
    Construct the piecewise polynomial without making checks.
    
    Takes the same parameters as the constructor. Input arguments
    `c` and `x` must be arrays of the correct shape and type.  The
    `c` array can only be of dtypes float and complex, and `x`
    array must have dtype float.
",method,"('cls', 'c', 'x', 'extrapolate', 'axis')","(nan, nan, nan, None, 0)","(nan, nan, nan, 'NoneType', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(c, x, extrapolate=None, axis=0)',)"
scipy,1.1.0,scipy.interpolate._cubic.BPoly.from_derivatives,interpolate._cubic.BPoly,from_derivatives,"Python Library Documentation: method from_derivatives in module scipy.interpolate.interpolate

from_derivatives(xi, yi, orders=None, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial in the Bernstein basis,
    compatible with the specified values and derivatives at breakpoints.
    
    Parameters
    ----------
    xi : array_like
        sorted 1D array of x-coordinates
    yi : array_like or list of array_likes
        ``yi[i][j]`` is the ``j``-th derivative known at ``xi[i]``
    orders : None or int or array_like of ints. Default: None.
        Specifies the degree of local polynomials. If not None, some
        derivatives are ignored.
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
    
    Notes
    -----
    If ``k`` derivatives are specified at a breakpoint ``x``, the
    constructed polynomial is exactly ``k`` times continuously
    differentiable at ``x``, unless the ``order`` is provided explicitly.
    In the latter case, the smoothness of the polynomial at
    the breakpoint is controlled by the ``order``.
    
    Deduces the number of derivatives to match at each end
    from ``order`` and the number of derivatives available. If
    possible it uses the same number of derivatives from
    each end; if the number is odd it tries to take the
    extra one from y2. In any case if not enough derivatives
    are available at one end or another it draws enough to
    make up the total from the other end.
    
    If the order is too high and not enough derivatives are available,
    an exception is raised.
    
    Examples
    --------
    
    >>> from scipy.interpolate import BPoly
    >>> BPoly.from_derivatives([0, 1], [[1, 2], [3, 4]])
    
    Creates a polynomial `f(x)` of degree 3, defined on `[0, 1]`
    such that `f(0) = 1, df/dx(0) = 2, f(1) = 3, df/dx(1) = 4`
    
    >>> BPoly.from_derivatives([0, 1, 2], [[0, 1], [0], [2]])
    
    Creates a piecewise polynomial `f(x)`, such that
    `f(0) = f(1) = 0`, `f(2) = 2`, and `df/dx(0) = 1`.
    Based on the number of derivatives provided, the order of the
    local polynomials is 2 on `[0, 1]` and 1 on `[1, 2]`.
    Notice that no restriction is imposed on the derivatives at
    `x = 1` and `x = 2`.
    
    Indeed, the explicit form of the polynomial is::
    
        f(x) = | x * (1 - x),  0 <= x < 1
               | 2 * (x - 1),  1 <= x <= 2
    
    So that f'(1-0) = -1 and f'(1+0) = 2
",method,"('(xi, yi, orders=None, extrapolate=None)',)",scipy,1.1.0,scipy.interpolate._cubic.BPoly.from_derivatives,interpolate._cubic.BPoly,from_derivatives,"Python Library Documentation: method from_derivatives in module scipy.interpolate.interpolate

from_derivatives(xi, yi, orders=None, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial in the Bernstein basis,
    compatible with the specified values and derivatives at breakpoints.
    
    Parameters
    ----------
    xi : array_like
        sorted 1D array of x-coordinates
    yi : array_like or list of array_likes
        ``yi[i][j]`` is the ``j``-th derivative known at ``xi[i]``
    orders : None or int or array_like of ints. Default: None.
        Specifies the degree of local polynomials. If not None, some
        derivatives are ignored.
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
    
    Notes
    -----
    If ``k`` derivatives are specified at a breakpoint ``x``, the
    constructed polynomial is exactly ``k`` times continuously
    differentiable at ``x``, unless the ``order`` is provided explicitly.
    In the latter case, the smoothness of the polynomial at
    the breakpoint is controlled by the ``order``.
    
    Deduces the number of derivatives to match at each end
    from ``order`` and the number of derivatives available. If
    possible it uses the same number of derivatives from
    each end; if the number is odd it tries to take the
    extra one from y2. In any case if not enough derivatives
    are available at one end or another it draws enough to
    make up the total from the other end.
    
    If the order is too high and not enough derivatives are available,
    an exception is raised.
    
    Examples
    --------
    
    >>> from scipy.interpolate import BPoly
    >>> BPoly.from_derivatives([0, 1], [[1, 2], [3, 4]])
    
    Creates a polynomial `f(x)` of degree 3, defined on `[0, 1]`
    such that `f(0) = 1, df/dx(0) = 2, f(1) = 3, df/dx(1) = 4`
    
    >>> BPoly.from_derivatives([0, 1, 2], [[0, 1], [0], [2]])
    
    Creates a piecewise polynomial `f(x)`, such that
    `f(0) = f(1) = 0`, `f(2) = 2`, and `df/dx(0) = 1`.
    Based on the number of derivatives provided, the order of the
    local polynomials is 2 on `[0, 1]` and 1 on `[1, 2]`.
    Notice that no restriction is imposed on the derivatives at
    `x = 1` and `x = 2`.
    
    Indeed, the explicit form of the polynomial is::
    
        f(x) = | x * (1 - x),  0 <= x < 1
               | 2 * (x - 1),  1 <= x <= 2
    
    So that f'(1-0) = -1 and f'(1+0) = 2
",method,"('cls', 'xi', 'yi', 'orders', 'extrapolate')","(nan, nan, nan, None, None)","(nan, nan, nan, 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(xi, yi, orders=None, extrapolate=None)',)"
scipy,1.1.0,scipy.interpolate._cubic.BPoly.from_power_basis,interpolate._cubic.BPoly,from_power_basis,"Python Library Documentation: method from_power_basis in module scipy.interpolate.interpolate

from_power_basis(pp, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial in Bernstein basis
    from a power basis polynomial.
    
    Parameters
    ----------
    pp : PPoly
        A piecewise polynomial in the power basis
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
",method,"('(pp, extrapolate=None)',)",scipy,1.1.0,scipy.interpolate._cubic.BPoly.from_power_basis,interpolate._cubic.BPoly,from_power_basis,"Python Library Documentation: method from_power_basis in module scipy.interpolate.interpolate

from_power_basis(pp, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial in Bernstein basis
    from a power basis polynomial.
    
    Parameters
    ----------
    pp : PPoly
        A piecewise polynomial in the power basis
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
",method,"('cls', 'pp', 'extrapolate')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(pp, extrapolate=None)',)"
scipy,1.1.0,scipy.interpolate._cubic.CubicSpline,interpolate._cubic,CubicSpline,"Python Library Documentation: class CubicSpline in module scipy.interpolate._cubic

class CubicSpline(scipy.interpolate.interpolate.PPoly)
 |  Cubic spline data interpolator.
 |  
 |  Interpolate data with a piecewise cubic polynomial which is twice
 |  continuously differentiable [1]_. The result is represented as a `PPoly`
 |  instance with breakpoints matching the given data.
 |  
 |  Parameters
 |  ----------
 |  x : array_like, shape (n,)
 |      1-d array containing values of the independent variable.
 |      Values must be real, finite and in strictly increasing order.
 |  y : array_like
 |      Array containing values of the dependent variable. It can have
 |      arbitrary number of dimensions, but the length along `axis` (see below)
 |      must match the length of `x`. Values must be finite.
 |  axis : int, optional
 |      Axis along which `y` is assumed to be varying. Meaning that for
 |      ``x[i]`` the corresponding values are ``np.take(y, i, axis=axis)``.
 |      Default is 0.
 |  bc_type : string or 2-tuple, optional
 |      Boundary condition type. Two additional equations, given by the
 |      boundary conditions, are required to determine all coefficients of
 |      polynomials on each segment [2]_.
 |  
 |      If `bc_type` is a string, then the specified condition will be applied
 |      at both ends of a spline. Available conditions are:
 |  
 |      * 'not-a-knot' (default): The first and second segment at a curve end
 |        are the same polynomial. It is a good default when there is no
 |        information on boundary conditions.
 |      * 'periodic': The interpolated functions is assumed to be periodic
 |        of period ``x[-1] - x[0]``. The first and last value of `y` must be
 |        identical: ``y[0] == y[-1]``. This boundary condition will result in
 |        ``y'[0] == y'[-1]`` and ``y''[0] == y''[-1]``.
 |      * 'clamped': The first derivative at curves ends are zero. Assuming
 |        a 1D `y`, ``bc_type=((1, 0.0), (1, 0.0))`` is the same condition.
 |      * 'natural': The second derivative at curve ends are zero. Assuming
 |        a 1D `y`, ``bc_type=((2, 0.0), (2, 0.0))`` is the same condition.
 |  
 |      If `bc_type` is a 2-tuple, the first and the second value will be
 |      applied at the curve start and end respectively. The tuple values can
 |      be one of the previously mentioned strings (except 'periodic') or a
 |      tuple `(order, deriv_values)` allowing to specify arbitrary
 |      derivatives at curve ends:
 |  
 |      * `order`: the derivative order, 1 or 2.
 |      * `deriv_value`: array_like containing derivative values, shape must
 |        be the same as `y`, excluding `axis` dimension. For example, if `y`
 |        is 1D, then `deriv_value` must be a scalar. If `y` is 3D with the
 |        shape (n0, n1, n2) and axis=2, then `deriv_value` must be 2D
 |        and have the shape (n0, n1).
 |  extrapolate : {bool, 'periodic', None}, optional
 |      If bool, determines whether to extrapolate to out-of-bounds points
 |      based on first and last intervals, or to return NaNs. If 'periodic',
 |      periodic extrapolation is used. If None (default), `extrapolate` is
 |      set to 'periodic' for ``bc_type='periodic'`` and to True otherwise.
 |  
 |  Attributes
 |  ----------
 |  x : ndarray, shape (n,)
 |      Breakpoints. The same `x` which was passed to the constructor.
 |  c : ndarray, shape (4, n-1, ...)
 |      Coefficients of the polynomials on each segment. The trailing
 |      dimensions match the dimensions of `y`, excluding `axis`. For example,
 |      if `y` is 1-d, then ``c[k, i]`` is a coefficient for
 |      ``(x-x[i])**(3-k)`` on the segment between ``x[i]`` and ``x[i+1]``.
 |  axis : int
 |      Interpolation axis. The same `axis` which was passed to the
 |      constructor.
 |  
 |  Methods
 |  -------
 |  __call__
 |  derivative
 |  antiderivative
 |  integrate
 |  roots
 |  
 |  See Also
 |  --------
 |  Akima1DInterpolator
 |  PchipInterpolator
 |  PPoly
 |  
 |  Notes
 |  -----
 |  Parameters `bc_type` and `interpolate` work independently, i.e. the former
 |  controls only construction of a spline, and the latter only evaluation.
 |  
 |  When a boundary condition is 'not-a-knot' and n = 2, it is replaced by
 |  a condition that the first derivative is equal to the linear interpolant
 |  slope. When both boundary conditions are 'not-a-knot' and n = 3, the
 |  solution is sought as a parabola passing through given points.
 |  
 |  When 'not-a-knot' boundary conditions is applied to both ends, the
 |  resulting spline will be the same as returned by `splrep` (with ``s=0``)
 |  and `InterpolatedUnivariateSpline`, but these two methods use a
 |  representation in B-spline basis.
 |  
 |  .. versionadded:: 0.18.0
 |  
 |  Examples
 |  --------
 |  In this example the cubic spline is used to interpolate a sampled sinusoid.
 |  You can see that the spline continuity property holds for the first and
 |  second derivatives and violates only for the third derivative.
 |  
 |  >>> from scipy.interpolate import CubicSpline
 |  >>> import matplotlib.pyplot as plt
 |  >>> x = np.arange(10)
 |  >>> y = np.sin(x)
 |  >>> cs = CubicSpline(x, y)
 |  >>> xs = np.arange(-0.5, 9.6, 0.1)
 |  >>> plt.figure(figsize=(6.5, 4))
 |  >>> plt.plot(x, y, 'o', label='data')
 |  >>> plt.plot(xs, np.sin(xs), label='true')
 |  >>> plt.plot(xs, cs(xs), label=""S"")
 |  >>> plt.plot(xs, cs(xs, 1), label=""S'"")
 |  >>> plt.plot(xs, cs(xs, 2), label=""S''"")
 |  >>> plt.plot(xs, cs(xs, 3), label=""S'''"")
 |  >>> plt.xlim(-0.5, 9.5)
 |  >>> plt.legend(loc='lower left', ncol=2)
 |  >>> plt.show()
 |  
 |  In the second example, the unit circle is interpolated with a spline. A
 |  periodic boundary condition is used. You can see that the first derivative
 |  values, ds/dx=0, ds/dy=1 at the periodic point (1, 0) are correctly
 |  computed. Note that a circle cannot be exactly represented by a cubic
 |  spline. To increase precision, more breakpoints would be required.
 |  
 |  >>> theta = 2 * np.pi * np.linspace(0, 1, 5)
 |  >>> y = np.c_[np.cos(theta), np.sin(theta)]
 |  >>> cs = CubicSpline(theta, y, bc_type='periodic')
 |  >>> print(""ds/dx={:.1f} ds/dy={:.1f}"".format(cs(0, 1)[0], cs(0, 1)[1]))
 |  ds/dx=0.0 ds/dy=1.0
 |  >>> xs = 2 * np.pi * np.linspace(0, 1, 100)
 |  >>> plt.figure(figsize=(6.5, 4))
 |  >>> plt.plot(y[:, 0], y[:, 1], 'o', label='data')
 |  >>> plt.plot(np.cos(xs), np.sin(xs), label='true')
 |  >>> plt.plot(cs(xs)[:, 0], cs(xs)[:, 1], label='spline')
 |  >>> plt.axes().set_aspect('equal')
 |  >>> plt.legend(loc='center')
 |  >>> plt.show()
 |  
 |  The third example is the interpolation of a polynomial y = x**3 on the
 |  interval 0 <= x<= 1. A cubic spline can represent this function exactly.
 |  To achieve that we need to specify values and first derivatives at
 |  endpoints of the interval. Note that y' = 3 * x**2 and thus y'(0) = 0 and
 |  y'(1) = 3.
 |  
 |  >>> cs = CubicSpline([0, 1], [0, 1], bc_type=((1, 0), (1, 3)))
 |  >>> x = np.linspace(0, 1)
 |  >>> np.allclose(x**3, cs(x))
 |  True
 |  
 |  References
 |  ----------
 |  .. [1] `Cubic Spline Interpolation
 |          <https://en.wikiversity.org/wiki/Cubic_Spline_Interpolation>`_
 |          on Wikiversity.
 |  .. [2] Carl de Boor, ""A Practical Guide to Splines"", Springer-Verlag, 1978.
 |  
 |  Method resolution order:
 |      CubicSpline
 |      scipy.interpolate.interpolate.PPoly
 |      scipy.interpolate.interpolate._PPolyBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, x, y, axis=0, bc_type='not-a-knot', extrapolate=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.interpolate.interpolate.PPoly:
 |  
 |  antiderivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the antiderivative.
 |      
 |      Antiderivative is also the indefinite integral of the function,
 |      and derivative is its inverse operation.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of antiderivative to evaluate. Default is 1, i.e. compute
 |          the first integral. If negative, the derivative is returned.
 |      
 |      Returns
 |      -------
 |      pp : PPoly
 |          Piecewise polynomial of order k2 = k + n representing
 |          the antiderivative of this polynomial.
 |      
 |      Notes
 |      -----
 |      The antiderivative returned by this function is continuous and
 |      continuously differentiable to order n-1, up to floating point
 |      rounding error.
 |      
 |      If antiderivative is computed and ``self.extrapolate='periodic'``,
 |      it will be set to False for the returned instance. This is done because
 |      the antiderivative is no longer periodic and its correct evaluation
 |      outside of the initially given x interval is difficult.
 |  
 |  derivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the derivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of derivative to evaluate. Default is 1, i.e. compute the
 |          first derivative. If negative, the antiderivative is returned.
 |      
 |      Returns
 |      -------
 |      pp : PPoly
 |          Piecewise polynomial of order k2 = k - n representing the derivative
 |          of this polynomial.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  integrate(self, a, b, extrapolate=None)
 |      Compute a definite integral over a piecewise polynomial.
 |      
 |      Parameters
 |      ----------
 |      a : float
 |          Lower integration bound
 |      b : float
 |          Upper integration bound
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      ig : array_like
 |          Definite integral of the piecewise polynomial over [a, b]
 |  
 |  roots(self, discontinuity=True, extrapolate=None)
 |      Find real roots of the the piecewise polynomial.
 |      
 |      Parameters
 |      ----------
 |      discontinuity : bool, optional
 |          Whether to report sign changes across discontinuities at
 |          breakpoints as roots.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to return roots from the polynomial
 |          extrapolated based on first and last intervals, 'periodic' works
 |          the same as False. If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      roots : ndarray
 |          Roots of the polynomial(s).
 |      
 |          If the PPoly object describes multiple polynomials, the
 |          return value is an object array whose each element is an
 |          ndarray containing the roots.
 |      
 |      See Also
 |      --------
 |      PPoly.solve
 |  
 |  solve(self, y=0.0, discontinuity=True, extrapolate=None)
 |      Find real solutions of the the equation ``pp(x) == y``.
 |      
 |      Parameters
 |      ----------
 |      y : float, optional
 |          Right-hand side. Default is zero.
 |      discontinuity : bool, optional
 |          Whether to report sign changes across discontinuities at
 |          breakpoints as roots.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to return roots from the polynomial
 |          extrapolated based on first and last intervals, 'periodic' works
 |          the same as False. If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      roots : ndarray
 |          Roots of the polynomial(s).
 |      
 |          If the PPoly object describes multiple polynomials, the
 |          return value is an object array whose each element is an
 |          ndarray containing the roots.
 |      
 |      Notes
 |      -----
 |      This routine works only on real-valued polynomials.
 |      
 |      If the piecewise polynomial contains sections that are
 |      identically zero, the root list will contain the start point
 |      of the corresponding interval, followed by a ``nan`` value.
 |      
 |      If the polynomial is discontinuous across a breakpoint, and
 |      there is a sign change across the breakpoint, this is reported
 |      if the `discont` parameter is True.
 |      
 |      Examples
 |      --------
 |      
 |      Finding roots of ``[x**2 - 1, (x - 1)**2]`` defined on intervals
 |      ``[-2, 1], [1, 2]``:
 |      
 |      >>> from scipy.interpolate import PPoly
 |      >>> pp = PPoly(np.array([[1, -4, 3], [1, 0, 0]]).T, [-2, 1, 2])
 |      >>> pp.roots()
 |      array([-1.,  1.])
 |  
 |  ----------------------------------------------------------------------
 |  Class methods inherited from scipy.interpolate.interpolate.PPoly:
 |  
 |  from_bernstein_basis(bp, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial in the power basis
 |      from a polynomial in Bernstein basis.
 |      
 |      Parameters
 |      ----------
 |      bp : BPoly
 |          A Bernstein basis polynomial, as created by BPoly
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |  
 |  from_spline(tck, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial from a spline
 |      
 |      Parameters
 |      ----------
 |      tck
 |          A spline, as returned by `splrep` or a BSpline object.
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.interpolate.interpolate.PPoly:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.interpolate.interpolate._PPolyBase:
 |  
 |  __call__(self, x, nu=0, extrapolate=None)
 |      Evaluate the piecewise polynomial or its derivative.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      nu : int, optional
 |          Order of derivative to evaluate. Must be non-negative.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  extend(self, c, x, right=None)
 |      Add additional breakpoints and coefficients to the polynomial.
 |      
 |      Parameters
 |      ----------
 |      c : ndarray, size (k, m, ...)
 |          Additional coefficients for polynomials in intervals. Note that
 |          the first additional interval will be formed using one of the
 |          `self.x` end points.
 |      x : ndarray, size (m,)
 |          Additional breakpoints. Must be sorted in the same order as
 |          `self.x` and either to the right or to the left of the current
 |          breakpoints.
 |      right
 |          Deprecated argument. Has no effect.
 |      
 |          .. deprecated:: 0.19
 |  
 |  ----------------------------------------------------------------------
 |  Class methods inherited from scipy.interpolate.interpolate._PPolyBase:
 |  
 |  construct_fast(c, x, extrapolate=None, axis=0) from builtins.type
 |      Construct the piecewise polynomial without making checks.
 |      
 |      Takes the same parameters as the constructor. Input arguments
 |      `c` and `x` must be arrays of the correct shape and type.  The
 |      `c` array can only be of dtypes float and complex, and `x`
 |      array must have dtype float.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.interpolate.interpolate._PPolyBase:
 |  
 |  axis
 |  
 |  c
 |  
 |  extrapolate
 |  
 |  x
",class,"(""(self, x, y, axis=0, bc_type='not-a-knot', extrapolate=None)"",)",scipy,1.1.0,scipy.interpolate._cubic.CubicSpline,interpolate._cubic,CubicSpline,"Python Library Documentation: class CubicSpline in module scipy.interpolate._cubic

class CubicSpline(scipy.interpolate.interpolate.PPoly)
 |  Cubic spline data interpolator.
 |  
 |  Interpolate data with a piecewise cubic polynomial which is twice
 |  continuously differentiable [1]_. The result is represented as a `PPoly`
 |  instance with breakpoints matching the given data.
 |  
 |  Parameters
 |  ----------
 |  x : array_like, shape (n,)
 |      1-d array containing values of the independent variable.
 |      Values must be real, finite and in strictly increasing order.
 |  y : array_like
 |      Array containing values of the dependent variable. It can have
 |      arbitrary number of dimensions, but the length along `axis` (see below)
 |      must match the length of `x`. Values must be finite.
 |  axis : int, optional
 |      Axis along which `y` is assumed to be varying. Meaning that for
 |      ``x[i]`` the corresponding values are ``np.take(y, i, axis=axis)``.
 |      Default is 0.
 |  bc_type : string or 2-tuple, optional
 |      Boundary condition type. Two additional equations, given by the
 |      boundary conditions, are required to determine all coefficients of
 |      polynomials on each segment [2]_.
 |  
 |      If `bc_type` is a string, then the specified condition will be applied
 |      at both ends of a spline. Available conditions are:
 |  
 |      * 'not-a-knot' (default): The first and second segment at a curve end
 |        are the same polynomial. It is a good default when there is no
 |        information on boundary conditions.
 |      * 'periodic': The interpolated functions is assumed to be periodic
 |        of period ``x[-1] - x[0]``. The first and last value of `y` must be
 |        identical: ``y[0] == y[-1]``. This boundary condition will result in
 |        ``y'[0] == y'[-1]`` and ``y''[0] == y''[-1]``.
 |      * 'clamped': The first derivative at curves ends are zero. Assuming
 |        a 1D `y`, ``bc_type=((1, 0.0), (1, 0.0))`` is the same condition.
 |      * 'natural': The second derivative at curve ends are zero. Assuming
 |        a 1D `y`, ``bc_type=((2, 0.0), (2, 0.0))`` is the same condition.
 |  
 |      If `bc_type` is a 2-tuple, the first and the second value will be
 |      applied at the curve start and end respectively. The tuple values can
 |      be one of the previously mentioned strings (except 'periodic') or a
 |      tuple `(order, deriv_values)` allowing to specify arbitrary
 |      derivatives at curve ends:
 |  
 |      * `order`: the derivative order, 1 or 2.
 |      * `deriv_value`: array_like containing derivative values, shape must
 |        be the same as `y`, excluding `axis` dimension. For example, if `y`
 |        is 1D, then `deriv_value` must be a scalar. If `y` is 3D with the
 |        shape (n0, n1, n2) and axis=2, then `deriv_value` must be 2D
 |        and have the shape (n0, n1).
 |  extrapolate : {bool, 'periodic', None}, optional
 |      If bool, determines whether to extrapolate to out-of-bounds points
 |      based on first and last intervals, or to return NaNs. If 'periodic',
 |      periodic extrapolation is used. If None (default), `extrapolate` is
 |      set to 'periodic' for ``bc_type='periodic'`` and to True otherwise.
 |  
 |  Attributes
 |  ----------
 |  x : ndarray, shape (n,)
 |      Breakpoints. The same `x` which was passed to the constructor.
 |  c : ndarray, shape (4, n-1, ...)
 |      Coefficients of the polynomials on each segment. The trailing
 |      dimensions match the dimensions of `y`, excluding `axis`. For example,
 |      if `y` is 1-d, then ``c[k, i]`` is a coefficient for
 |      ``(x-x[i])**(3-k)`` on the segment between ``x[i]`` and ``x[i+1]``.
 |  axis : int
 |      Interpolation axis. The same `axis` which was passed to the
 |      constructor.
 |  
 |  Methods
 |  -------
 |  __call__
 |  derivative
 |  antiderivative
 |  integrate
 |  roots
 |  
 |  See Also
 |  --------
 |  Akima1DInterpolator
 |  PchipInterpolator
 |  PPoly
 |  
 |  Notes
 |  -----
 |  Parameters `bc_type` and `interpolate` work independently, i.e. the former
 |  controls only construction of a spline, and the latter only evaluation.
 |  
 |  When a boundary condition is 'not-a-knot' and n = 2, it is replaced by
 |  a condition that the first derivative is equal to the linear interpolant
 |  slope. When both boundary conditions are 'not-a-knot' and n = 3, the
 |  solution is sought as a parabola passing through given points.
 |  
 |  When 'not-a-knot' boundary conditions is applied to both ends, the
 |  resulting spline will be the same as returned by `splrep` (with ``s=0``)
 |  and `InterpolatedUnivariateSpline`, but these two methods use a
 |  representation in B-spline basis.
 |  
 |  .. versionadded:: 0.18.0
 |  
 |  Examples
 |  --------
 |  In this example the cubic spline is used to interpolate a sampled sinusoid.
 |  You can see that the spline continuity property holds for the first and
 |  second derivatives and violates only for the third derivative.
 |  
 |  >>> from scipy.interpolate import CubicSpline
 |  >>> import matplotlib.pyplot as plt
 |  >>> x = np.arange(10)
 |  >>> y = np.sin(x)
 |  >>> cs = CubicSpline(x, y)
 |  >>> xs = np.arange(-0.5, 9.6, 0.1)
 |  >>> plt.figure(figsize=(6.5, 4))
 |  >>> plt.plot(x, y, 'o', label='data')
 |  >>> plt.plot(xs, np.sin(xs), label='true')
 |  >>> plt.plot(xs, cs(xs), label=""S"")
 |  >>> plt.plot(xs, cs(xs, 1), label=""S'"")
 |  >>> plt.plot(xs, cs(xs, 2), label=""S''"")
 |  >>> plt.plot(xs, cs(xs, 3), label=""S'''"")
 |  >>> plt.xlim(-0.5, 9.5)
 |  >>> plt.legend(loc='lower left', ncol=2)
 |  >>> plt.show()
 |  
 |  In the second example, the unit circle is interpolated with a spline. A
 |  periodic boundary condition is used. You can see that the first derivative
 |  values, ds/dx=0, ds/dy=1 at the periodic point (1, 0) are correctly
 |  computed. Note that a circle cannot be exactly represented by a cubic
 |  spline. To increase precision, more breakpoints would be required.
 |  
 |  >>> theta = 2 * np.pi * np.linspace(0, 1, 5)
 |  >>> y = np.c_[np.cos(theta), np.sin(theta)]
 |  >>> cs = CubicSpline(theta, y, bc_type='periodic')
 |  >>> print(""ds/dx={:.1f} ds/dy={:.1f}"".format(cs(0, 1)[0], cs(0, 1)[1]))
 |  ds/dx=0.0 ds/dy=1.0
 |  >>> xs = 2 * np.pi * np.linspace(0, 1, 100)
 |  >>> plt.figure(figsize=(6.5, 4))
 |  >>> plt.plot(y[:, 0], y[:, 1], 'o', label='data')
 |  >>> plt.plot(np.cos(xs), np.sin(xs), label='true')
 |  >>> plt.plot(cs(xs)[:, 0], cs(xs)[:, 1], label='spline')
 |  >>> plt.axes().set_aspect('equal')
 |  >>> plt.legend(loc='center')
 |  >>> plt.show()
 |  
 |  The third example is the interpolation of a polynomial y = x**3 on the
 |  interval 0 <= x<= 1. A cubic spline can represent this function exactly.
 |  To achieve that we need to specify values and first derivatives at
 |  endpoints of the interval. Note that y' = 3 * x**2 and thus y'(0) = 0 and
 |  y'(1) = 3.
 |  
 |  >>> cs = CubicSpline([0, 1], [0, 1], bc_type=((1, 0), (1, 3)))
 |  >>> x = np.linspace(0, 1)
 |  >>> np.allclose(x**3, cs(x))
 |  True
 |  
 |  References
 |  ----------
 |  .. [1] `Cubic Spline Interpolation
 |          <https://en.wikiversity.org/wiki/Cubic_Spline_Interpolation>`_
 |          on Wikiversity.
 |  .. [2] Carl de Boor, ""A Practical Guide to Splines"", Springer-Verlag, 1978.
 |  
 |  Method resolution order:
 |      CubicSpline
 |      scipy.interpolate.interpolate.PPoly
 |      scipy.interpolate.interpolate._PPolyBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, x, y, axis=0, bc_type='not-a-knot', extrapolate=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.interpolate.interpolate.PPoly:
 |  
 |  antiderivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the antiderivative.
 |      
 |      Antiderivative is also the indefinite integral of the function,
 |      and derivative is its inverse operation.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of antiderivative to evaluate. Default is 1, i.e. compute
 |          the first integral. If negative, the derivative is returned.
 |      
 |      Returns
 |      -------
 |      pp : PPoly
 |          Piecewise polynomial of order k2 = k + n representing
 |          the antiderivative of this polynomial.
 |      
 |      Notes
 |      -----
 |      The antiderivative returned by this function is continuous and
 |      continuously differentiable to order n-1, up to floating point
 |      rounding error.
 |      
 |      If antiderivative is computed and ``self.extrapolate='periodic'``,
 |      it will be set to False for the returned instance. This is done because
 |      the antiderivative is no longer periodic and its correct evaluation
 |      outside of the initially given x interval is difficult.
 |  
 |  derivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the derivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of derivative to evaluate. Default is 1, i.e. compute the
 |          first derivative. If negative, the antiderivative is returned.
 |      
 |      Returns
 |      -------
 |      pp : PPoly
 |          Piecewise polynomial of order k2 = k - n representing the derivative
 |          of this polynomial.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  integrate(self, a, b, extrapolate=None)
 |      Compute a definite integral over a piecewise polynomial.
 |      
 |      Parameters
 |      ----------
 |      a : float
 |          Lower integration bound
 |      b : float
 |          Upper integration bound
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      ig : array_like
 |          Definite integral of the piecewise polynomial over [a, b]
 |  
 |  roots(self, discontinuity=True, extrapolate=None)
 |      Find real roots of the the piecewise polynomial.
 |      
 |      Parameters
 |      ----------
 |      discontinuity : bool, optional
 |          Whether to report sign changes across discontinuities at
 |          breakpoints as roots.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to return roots from the polynomial
 |          extrapolated based on first and last intervals, 'periodic' works
 |          the same as False. If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      roots : ndarray
 |          Roots of the polynomial(s).
 |      
 |          If the PPoly object describes multiple polynomials, the
 |          return value is an object array whose each element is an
 |          ndarray containing the roots.
 |      
 |      See Also
 |      --------
 |      PPoly.solve
 |  
 |  solve(self, y=0.0, discontinuity=True, extrapolate=None)
 |      Find real solutions of the the equation ``pp(x) == y``.
 |      
 |      Parameters
 |      ----------
 |      y : float, optional
 |          Right-hand side. Default is zero.
 |      discontinuity : bool, optional
 |          Whether to report sign changes across discontinuities at
 |          breakpoints as roots.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to return roots from the polynomial
 |          extrapolated based on first and last intervals, 'periodic' works
 |          the same as False. If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      roots : ndarray
 |          Roots of the polynomial(s).
 |      
 |          If the PPoly object describes multiple polynomials, the
 |          return value is an object array whose each element is an
 |          ndarray containing the roots.
 |      
 |      Notes
 |      -----
 |      This routine works only on real-valued polynomials.
 |      
 |      If the piecewise polynomial contains sections that are
 |      identically zero, the root list will contain the start point
 |      of the corresponding interval, followed by a ``nan`` value.
 |      
 |      If the polynomial is discontinuous across a breakpoint, and
 |      there is a sign change across the breakpoint, this is reported
 |      if the `discont` parameter is True.
 |      
 |      Examples
 |      --------
 |      
 |      Finding roots of ``[x**2 - 1, (x - 1)**2]`` defined on intervals
 |      ``[-2, 1], [1, 2]``:
 |      
 |      >>> from scipy.interpolate import PPoly
 |      >>> pp = PPoly(np.array([[1, -4, 3], [1, 0, 0]]).T, [-2, 1, 2])
 |      >>> pp.roots()
 |      array([-1.,  1.])
 |  
 |  ----------------------------------------------------------------------
 |  Class methods inherited from scipy.interpolate.interpolate.PPoly:
 |  
 |  from_bernstein_basis(bp, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial in the power basis
 |      from a polynomial in Bernstein basis.
 |      
 |      Parameters
 |      ----------
 |      bp : BPoly
 |          A Bernstein basis polynomial, as created by BPoly
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |  
 |  from_spline(tck, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial from a spline
 |      
 |      Parameters
 |      ----------
 |      tck
 |          A spline, as returned by `splrep` or a BSpline object.
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.interpolate.interpolate.PPoly:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.interpolate.interpolate._PPolyBase:
 |  
 |  __call__(self, x, nu=0, extrapolate=None)
 |      Evaluate the piecewise polynomial or its derivative.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      nu : int, optional
 |          Order of derivative to evaluate. Must be non-negative.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  extend(self, c, x, right=None)
 |      Add additional breakpoints and coefficients to the polynomial.
 |      
 |      Parameters
 |      ----------
 |      c : ndarray, size (k, m, ...)
 |          Additional coefficients for polynomials in intervals. Note that
 |          the first additional interval will be formed using one of the
 |          `self.x` end points.
 |      x : ndarray, size (m,)
 |          Additional breakpoints. Must be sorted in the same order as
 |          `self.x` and either to the right or to the left of the current
 |          breakpoints.
 |      right
 |          Deprecated argument. Has no effect.
 |      
 |          .. deprecated:: 0.19
 |  
 |  ----------------------------------------------------------------------
 |  Class methods inherited from scipy.interpolate.interpolate._PPolyBase:
 |  
 |  construct_fast(c, x, extrapolate=None, axis=0) from builtins.type
 |      Construct the piecewise polynomial without making checks.
 |      
 |      Takes the same parameters as the constructor. Input arguments
 |      `c` and `x` must be arrays of the correct shape and type.  The
 |      `c` array can only be of dtypes float and complex, and `x`
 |      array must have dtype float.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.interpolate.interpolate._PPolyBase:
 |  
 |  axis
 |  
 |  c
 |  
 |  extrapolate
 |  
 |  x
",class,"('self', 'x', 'y', 'axis', 'bc_type', 'extrapolate')","(nan, nan, nan, 0, 'not-a-knot', None)","(nan, nan, nan, 'int', 'str', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(self, x, y, axis=0, bc_type='not-a-knot', extrapolate=None)"",)"
scipy,1.1.0,scipy.interpolate._cubic.CubicSpline.construct_fast,interpolate._cubic.CubicSpline,construct_fast,"Python Library Documentation: method construct_fast in module scipy.interpolate.interpolate

construct_fast(c, x, extrapolate=None, axis=0) method of builtins.type instance
    Construct the piecewise polynomial without making checks.
    
    Takes the same parameters as the constructor. Input arguments
    `c` and `x` must be arrays of the correct shape and type.  The
    `c` array can only be of dtypes float and complex, and `x`
    array must have dtype float.
",method,"('(c, x, extrapolate=None, axis=0)',)",scipy,1.1.0,scipy.interpolate._cubic.CubicSpline.construct_fast,interpolate._cubic.CubicSpline,construct_fast,"Python Library Documentation: method construct_fast in module scipy.interpolate.interpolate

construct_fast(c, x, extrapolate=None, axis=0) method of builtins.type instance
    Construct the piecewise polynomial without making checks.
    
    Takes the same parameters as the constructor. Input arguments
    `c` and `x` must be arrays of the correct shape and type.  The
    `c` array can only be of dtypes float and complex, and `x`
    array must have dtype float.
",method,"('cls', 'c', 'x', 'extrapolate', 'axis')","(nan, nan, nan, None, 0)","(nan, nan, nan, 'NoneType', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(c, x, extrapolate=None, axis=0)',)"
scipy,1.1.0,scipy.interpolate._cubic.CubicSpline.from_bernstein_basis,interpolate._cubic.CubicSpline,from_bernstein_basis,"Python Library Documentation: method from_bernstein_basis in module scipy.interpolate.interpolate

from_bernstein_basis(bp, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial in the power basis
    from a polynomial in Bernstein basis.
    
    Parameters
    ----------
    bp : BPoly
        A Bernstein basis polynomial, as created by BPoly
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
",method,"('(bp, extrapolate=None)',)",scipy,1.1.0,scipy.interpolate._cubic.CubicSpline.from_bernstein_basis,interpolate._cubic.CubicSpline,from_bernstein_basis,"Python Library Documentation: method from_bernstein_basis in module scipy.interpolate.interpolate

from_bernstein_basis(bp, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial in the power basis
    from a polynomial in Bernstein basis.
    
    Parameters
    ----------
    bp : BPoly
        A Bernstein basis polynomial, as created by BPoly
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
",method,"('cls', 'bp', 'extrapolate')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(bp, extrapolate=None)',)"
scipy,1.1.0,scipy.interpolate._cubic.CubicSpline.from_spline,interpolate._cubic.CubicSpline,from_spline,"Python Library Documentation: method from_spline in module scipy.interpolate.interpolate

from_spline(tck, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial from a spline
    
    Parameters
    ----------
    tck
        A spline, as returned by `splrep` or a BSpline object.
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
",method,"('(tck, extrapolate=None)',)",scipy,1.1.0,scipy.interpolate._cubic.CubicSpline.from_spline,interpolate._cubic.CubicSpline,from_spline,"Python Library Documentation: method from_spline in module scipy.interpolate.interpolate

from_spline(tck, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial from a spline
    
    Parameters
    ----------
    tck
        A spline, as returned by `splrep` or a BSpline object.
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
",method,"('cls', 'tck', 'extrapolate')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(tck, extrapolate=None)',)"
scipy,1.1.0,scipy.interpolate._cubic.PPoly,interpolate._cubic,PPoly,"Python Library Documentation: class PPoly in module scipy.interpolate.interpolate

class PPoly(_PPolyBase)
 |  Piecewise polynomial in terms of coefficients and breakpoints
 |  
 |  The polynomial between ``x[i]`` and ``x[i + 1]`` is written in the
 |  local power basis::
 |  
 |      S = sum(c[m, i] * (xp - x[i])**(k-m) for m in range(k+1))
 |  
 |  where ``k`` is the degree of the polynomial.
 |  
 |  Parameters
 |  ----------
 |  c : ndarray, shape (k, m, ...)
 |      Polynomial coefficients, order `k` and `m` intervals
 |  x : ndarray, shape (m+1,)
 |      Polynomial breakpoints. Must be sorted in either increasing or
 |      decreasing order.
 |  extrapolate : bool or 'periodic', optional
 |      If bool, determines whether to extrapolate to out-of-bounds points
 |      based on first and last intervals, or to return NaNs. If 'periodic',
 |      periodic extrapolation is used. Default is True.
 |  axis : int, optional
 |      Interpolation axis. Default is zero.
 |  
 |  Attributes
 |  ----------
 |  x : ndarray
 |      Breakpoints.
 |  c : ndarray
 |      Coefficients of the polynomials. They are reshaped
 |      to a 3-dimensional array with the last dimension representing
 |      the trailing dimensions of the original coefficient array.
 |  axis : int
 |      Interpolation axis.
 |  
 |  Methods
 |  -------
 |  __call__
 |  derivative
 |  antiderivative
 |  integrate
 |  solve
 |  roots
 |  extend
 |  from_spline
 |  from_bernstein_basis
 |  construct_fast
 |  
 |  See also
 |  --------
 |  BPoly : piecewise polynomials in the Bernstein basis
 |  
 |  Notes
 |  -----
 |  High-order polynomials in the power basis can be numerically
 |  unstable.  Precision problems can start to appear for orders
 |  larger than 20-30.
 |  
 |  Method resolution order:
 |      PPoly
 |      _PPolyBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  antiderivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the antiderivative.
 |      
 |      Antiderivative is also the indefinite integral of the function,
 |      and derivative is its inverse operation.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of antiderivative to evaluate. Default is 1, i.e. compute
 |          the first integral. If negative, the derivative is returned.
 |      
 |      Returns
 |      -------
 |      pp : PPoly
 |          Piecewise polynomial of order k2 = k + n representing
 |          the antiderivative of this polynomial.
 |      
 |      Notes
 |      -----
 |      The antiderivative returned by this function is continuous and
 |      continuously differentiable to order n-1, up to floating point
 |      rounding error.
 |      
 |      If antiderivative is computed and ``self.extrapolate='periodic'``,
 |      it will be set to False for the returned instance. This is done because
 |      the antiderivative is no longer periodic and its correct evaluation
 |      outside of the initially given x interval is difficult.
 |  
 |  derivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the derivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of derivative to evaluate. Default is 1, i.e. compute the
 |          first derivative. If negative, the antiderivative is returned.
 |      
 |      Returns
 |      -------
 |      pp : PPoly
 |          Piecewise polynomial of order k2 = k - n representing the derivative
 |          of this polynomial.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  integrate(self, a, b, extrapolate=None)
 |      Compute a definite integral over a piecewise polynomial.
 |      
 |      Parameters
 |      ----------
 |      a : float
 |          Lower integration bound
 |      b : float
 |          Upper integration bound
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      ig : array_like
 |          Definite integral of the piecewise polynomial over [a, b]
 |  
 |  roots(self, discontinuity=True, extrapolate=None)
 |      Find real roots of the the piecewise polynomial.
 |      
 |      Parameters
 |      ----------
 |      discontinuity : bool, optional
 |          Whether to report sign changes across discontinuities at
 |          breakpoints as roots.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to return roots from the polynomial
 |          extrapolated based on first and last intervals, 'periodic' works
 |          the same as False. If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      roots : ndarray
 |          Roots of the polynomial(s).
 |      
 |          If the PPoly object describes multiple polynomials, the
 |          return value is an object array whose each element is an
 |          ndarray containing the roots.
 |      
 |      See Also
 |      --------
 |      PPoly.solve
 |  
 |  solve(self, y=0.0, discontinuity=True, extrapolate=None)
 |      Find real solutions of the the equation ``pp(x) == y``.
 |      
 |      Parameters
 |      ----------
 |      y : float, optional
 |          Right-hand side. Default is zero.
 |      discontinuity : bool, optional
 |          Whether to report sign changes across discontinuities at
 |          breakpoints as roots.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to return roots from the polynomial
 |          extrapolated based on first and last intervals, 'periodic' works
 |          the same as False. If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      roots : ndarray
 |          Roots of the polynomial(s).
 |      
 |          If the PPoly object describes multiple polynomials, the
 |          return value is an object array whose each element is an
 |          ndarray containing the roots.
 |      
 |      Notes
 |      -----
 |      This routine works only on real-valued polynomials.
 |      
 |      If the piecewise polynomial contains sections that are
 |      identically zero, the root list will contain the start point
 |      of the corresponding interval, followed by a ``nan`` value.
 |      
 |      If the polynomial is discontinuous across a breakpoint, and
 |      there is a sign change across the breakpoint, this is reported
 |      if the `discont` parameter is True.
 |      
 |      Examples
 |      --------
 |      
 |      Finding roots of ``[x**2 - 1, (x - 1)**2]`` defined on intervals
 |      ``[-2, 1], [1, 2]``:
 |      
 |      >>> from scipy.interpolate import PPoly
 |      >>> pp = PPoly(np.array([[1, -4, 3], [1, 0, 0]]).T, [-2, 1, 2])
 |      >>> pp.roots()
 |      array([-1.,  1.])
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_bernstein_basis(bp, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial in the power basis
 |      from a polynomial in Bernstein basis.
 |      
 |      Parameters
 |      ----------
 |      bp : BPoly
 |          A Bernstein basis polynomial, as created by BPoly
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |  
 |  from_spline(tck, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial from a spline
 |      
 |      Parameters
 |      ----------
 |      tck
 |          A spline, as returned by `splrep` or a BSpline object.
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _PPolyBase:
 |  
 |  __call__(self, x, nu=0, extrapolate=None)
 |      Evaluate the piecewise polynomial or its derivative.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      nu : int, optional
 |          Order of derivative to evaluate. Must be non-negative.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  __init__(self, c, x, extrapolate=None, axis=0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  extend(self, c, x, right=None)
 |      Add additional breakpoints and coefficients to the polynomial.
 |      
 |      Parameters
 |      ----------
 |      c : ndarray, size (k, m, ...)
 |          Additional coefficients for polynomials in intervals. Note that
 |          the first additional interval will be formed using one of the
 |          `self.x` end points.
 |      x : ndarray, size (m,)
 |          Additional breakpoints. Must be sorted in the same order as
 |          `self.x` and either to the right or to the left of the current
 |          breakpoints.
 |      right
 |          Deprecated argument. Has no effect.
 |      
 |          .. deprecated:: 0.19
 |  
 |  ----------------------------------------------------------------------
 |  Class methods inherited from _PPolyBase:
 |  
 |  construct_fast(c, x, extrapolate=None, axis=0) from builtins.type
 |      Construct the piecewise polynomial without making checks.
 |      
 |      Takes the same parameters as the constructor. Input arguments
 |      `c` and `x` must be arrays of the correct shape and type.  The
 |      `c` array can only be of dtypes float and complex, and `x`
 |      array must have dtype float.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _PPolyBase:
 |  
 |  axis
 |  
 |  c
 |  
 |  extrapolate
 |  
 |  x
",class,"('(self, c, x, extrapolate=None, axis=0)',)",scipy,1.1.0,scipy.interpolate._cubic.PPoly,interpolate._cubic,PPoly,"Python Library Documentation: class PPoly in module scipy.interpolate.interpolate

class PPoly(_PPolyBase)
 |  Piecewise polynomial in terms of coefficients and breakpoints
 |  
 |  The polynomial between ``x[i]`` and ``x[i + 1]`` is written in the
 |  local power basis::
 |  
 |      S = sum(c[m, i] * (xp - x[i])**(k-m) for m in range(k+1))
 |  
 |  where ``k`` is the degree of the polynomial.
 |  
 |  Parameters
 |  ----------
 |  c : ndarray, shape (k, m, ...)
 |      Polynomial coefficients, order `k` and `m` intervals
 |  x : ndarray, shape (m+1,)
 |      Polynomial breakpoints. Must be sorted in either increasing or
 |      decreasing order.
 |  extrapolate : bool or 'periodic', optional
 |      If bool, determines whether to extrapolate to out-of-bounds points
 |      based on first and last intervals, or to return NaNs. If 'periodic',
 |      periodic extrapolation is used. Default is True.
 |  axis : int, optional
 |      Interpolation axis. Default is zero.
 |  
 |  Attributes
 |  ----------
 |  x : ndarray
 |      Breakpoints.
 |  c : ndarray
 |      Coefficients of the polynomials. They are reshaped
 |      to a 3-dimensional array with the last dimension representing
 |      the trailing dimensions of the original coefficient array.
 |  axis : int
 |      Interpolation axis.
 |  
 |  Methods
 |  -------
 |  __call__
 |  derivative
 |  antiderivative
 |  integrate
 |  solve
 |  roots
 |  extend
 |  from_spline
 |  from_bernstein_basis
 |  construct_fast
 |  
 |  See also
 |  --------
 |  BPoly : piecewise polynomials in the Bernstein basis
 |  
 |  Notes
 |  -----
 |  High-order polynomials in the power basis can be numerically
 |  unstable.  Precision problems can start to appear for orders
 |  larger than 20-30.
 |  
 |  Method resolution order:
 |      PPoly
 |      _PPolyBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  antiderivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the antiderivative.
 |      
 |      Antiderivative is also the indefinite integral of the function,
 |      and derivative is its inverse operation.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of antiderivative to evaluate. Default is 1, i.e. compute
 |          the first integral. If negative, the derivative is returned.
 |      
 |      Returns
 |      -------
 |      pp : PPoly
 |          Piecewise polynomial of order k2 = k + n representing
 |          the antiderivative of this polynomial.
 |      
 |      Notes
 |      -----
 |      The antiderivative returned by this function is continuous and
 |      continuously differentiable to order n-1, up to floating point
 |      rounding error.
 |      
 |      If antiderivative is computed and ``self.extrapolate='periodic'``,
 |      it will be set to False for the returned instance. This is done because
 |      the antiderivative is no longer periodic and its correct evaluation
 |      outside of the initially given x interval is difficult.
 |  
 |  derivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the derivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of derivative to evaluate. Default is 1, i.e. compute the
 |          first derivative. If negative, the antiderivative is returned.
 |      
 |      Returns
 |      -------
 |      pp : PPoly
 |          Piecewise polynomial of order k2 = k - n representing the derivative
 |          of this polynomial.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  integrate(self, a, b, extrapolate=None)
 |      Compute a definite integral over a piecewise polynomial.
 |      
 |      Parameters
 |      ----------
 |      a : float
 |          Lower integration bound
 |      b : float
 |          Upper integration bound
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      ig : array_like
 |          Definite integral of the piecewise polynomial over [a, b]
 |  
 |  roots(self, discontinuity=True, extrapolate=None)
 |      Find real roots of the the piecewise polynomial.
 |      
 |      Parameters
 |      ----------
 |      discontinuity : bool, optional
 |          Whether to report sign changes across discontinuities at
 |          breakpoints as roots.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to return roots from the polynomial
 |          extrapolated based on first and last intervals, 'periodic' works
 |          the same as False. If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      roots : ndarray
 |          Roots of the polynomial(s).
 |      
 |          If the PPoly object describes multiple polynomials, the
 |          return value is an object array whose each element is an
 |          ndarray containing the roots.
 |      
 |      See Also
 |      --------
 |      PPoly.solve
 |  
 |  solve(self, y=0.0, discontinuity=True, extrapolate=None)
 |      Find real solutions of the the equation ``pp(x) == y``.
 |      
 |      Parameters
 |      ----------
 |      y : float, optional
 |          Right-hand side. Default is zero.
 |      discontinuity : bool, optional
 |          Whether to report sign changes across discontinuities at
 |          breakpoints as roots.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to return roots from the polynomial
 |          extrapolated based on first and last intervals, 'periodic' works
 |          the same as False. If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      roots : ndarray
 |          Roots of the polynomial(s).
 |      
 |          If the PPoly object describes multiple polynomials, the
 |          return value is an object array whose each element is an
 |          ndarray containing the roots.
 |      
 |      Notes
 |      -----
 |      This routine works only on real-valued polynomials.
 |      
 |      If the piecewise polynomial contains sections that are
 |      identically zero, the root list will contain the start point
 |      of the corresponding interval, followed by a ``nan`` value.
 |      
 |      If the polynomial is discontinuous across a breakpoint, and
 |      there is a sign change across the breakpoint, this is reported
 |      if the `discont` parameter is True.
 |      
 |      Examples
 |      --------
 |      
 |      Finding roots of ``[x**2 - 1, (x - 1)**2]`` defined on intervals
 |      ``[-2, 1], [1, 2]``:
 |      
 |      >>> from scipy.interpolate import PPoly
 |      >>> pp = PPoly(np.array([[1, -4, 3], [1, 0, 0]]).T, [-2, 1, 2])
 |      >>> pp.roots()
 |      array([-1.,  1.])
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_bernstein_basis(bp, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial in the power basis
 |      from a polynomial in Bernstein basis.
 |      
 |      Parameters
 |      ----------
 |      bp : BPoly
 |          A Bernstein basis polynomial, as created by BPoly
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |  
 |  from_spline(tck, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial from a spline
 |      
 |      Parameters
 |      ----------
 |      tck
 |          A spline, as returned by `splrep` or a BSpline object.
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _PPolyBase:
 |  
 |  __call__(self, x, nu=0, extrapolate=None)
 |      Evaluate the piecewise polynomial or its derivative.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      nu : int, optional
 |          Order of derivative to evaluate. Must be non-negative.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  __init__(self, c, x, extrapolate=None, axis=0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  extend(self, c, x, right=None)
 |      Add additional breakpoints and coefficients to the polynomial.
 |      
 |      Parameters
 |      ----------
 |      c : ndarray, size (k, m, ...)
 |          Additional coefficients for polynomials in intervals. Note that
 |          the first additional interval will be formed using one of the
 |          `self.x` end points.
 |      x : ndarray, size (m,)
 |          Additional breakpoints. Must be sorted in the same order as
 |          `self.x` and either to the right or to the left of the current
 |          breakpoints.
 |      right
 |          Deprecated argument. Has no effect.
 |      
 |          .. deprecated:: 0.19
 |  
 |  ----------------------------------------------------------------------
 |  Class methods inherited from _PPolyBase:
 |  
 |  construct_fast(c, x, extrapolate=None, axis=0) from builtins.type
 |      Construct the piecewise polynomial without making checks.
 |      
 |      Takes the same parameters as the constructor. Input arguments
 |      `c` and `x` must be arrays of the correct shape and type.  The
 |      `c` array can only be of dtypes float and complex, and `x`
 |      array must have dtype float.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _PPolyBase:
 |  
 |  axis
 |  
 |  c
 |  
 |  extrapolate
 |  
 |  x
",class,"('self', 'c', 'x', 'extrapolate', 'axis')","(nan, nan, nan, None, 0)","(nan, nan, nan, 'NoneType', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, c, x, extrapolate=None, axis=0)',)"
scipy,1.1.0,scipy.interpolate._cubic.PPoly.construct_fast,interpolate._cubic.PPoly,construct_fast,"Python Library Documentation: method construct_fast in module scipy.interpolate.interpolate

construct_fast(c, x, extrapolate=None, axis=0) method of builtins.type instance
    Construct the piecewise polynomial without making checks.
    
    Takes the same parameters as the constructor. Input arguments
    `c` and `x` must be arrays of the correct shape and type.  The
    `c` array can only be of dtypes float and complex, and `x`
    array must have dtype float.
",method,"('(c, x, extrapolate=None, axis=0)',)",scipy,1.1.0,scipy.interpolate._cubic.PPoly.construct_fast,interpolate._cubic.PPoly,construct_fast,"Python Library Documentation: method construct_fast in module scipy.interpolate.interpolate

construct_fast(c, x, extrapolate=None, axis=0) method of builtins.type instance
    Construct the piecewise polynomial without making checks.
    
    Takes the same parameters as the constructor. Input arguments
    `c` and `x` must be arrays of the correct shape and type.  The
    `c` array can only be of dtypes float and complex, and `x`
    array must have dtype float.
",method,"('cls', 'c', 'x', 'extrapolate', 'axis')","(nan, nan, nan, None, 0)","(nan, nan, nan, 'NoneType', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(c, x, extrapolate=None, axis=0)',)"
scipy,1.1.0,scipy.interpolate._cubic.PPoly.from_bernstein_basis,interpolate._cubic.PPoly,from_bernstein_basis,"Python Library Documentation: method from_bernstein_basis in module scipy.interpolate.interpolate

from_bernstein_basis(bp, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial in the power basis
    from a polynomial in Bernstein basis.
    
    Parameters
    ----------
    bp : BPoly
        A Bernstein basis polynomial, as created by BPoly
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
",method,"('(bp, extrapolate=None)',)",scipy,1.1.0,scipy.interpolate._cubic.PPoly.from_bernstein_basis,interpolate._cubic.PPoly,from_bernstein_basis,"Python Library Documentation: method from_bernstein_basis in module scipy.interpolate.interpolate

from_bernstein_basis(bp, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial in the power basis
    from a polynomial in Bernstein basis.
    
    Parameters
    ----------
    bp : BPoly
        A Bernstein basis polynomial, as created by BPoly
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
",method,"('cls', 'bp', 'extrapolate')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(bp, extrapolate=None)',)"
scipy,1.1.0,scipy.interpolate._cubic.PPoly.from_spline,interpolate._cubic.PPoly,from_spline,"Python Library Documentation: method from_spline in module scipy.interpolate.interpolate

from_spline(tck, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial from a spline
    
    Parameters
    ----------
    tck
        A spline, as returned by `splrep` or a BSpline object.
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
",method,"('(tck, extrapolate=None)',)",scipy,1.1.0,scipy.interpolate._cubic.PPoly.from_spline,interpolate._cubic.PPoly,from_spline,"Python Library Documentation: method from_spline in module scipy.interpolate.interpolate

from_spline(tck, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial from a spline
    
    Parameters
    ----------
    tck
        A spline, as returned by `splrep` or a BSpline object.
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
",method,"('cls', 'tck', 'extrapolate')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(tck, extrapolate=None)',)"
scipy,1.1.0,scipy.interpolate._cubic.PchipInterpolator,interpolate._cubic,PchipInterpolator,"Python Library Documentation: class PchipInterpolator in module scipy.interpolate._cubic

class PchipInterpolator(scipy.interpolate.interpolate.BPoly)
 |  PCHIP 1-d monotonic cubic interpolation.
 |  
 |  `x` and `y` are arrays of values used to approximate some function f,
 |  with ``y = f(x)``. The interpolant uses monotonic cubic splines
 |  to find the value of new points. (PCHIP stands for Piecewise Cubic
 |  Hermite Interpolating Polynomial).
 |  
 |  Parameters
 |  ----------
 |  x : ndarray
 |      A 1-D array of monotonically increasing real values.  `x` cannot
 |      include duplicate values (otherwise f is overspecified)
 |  y : ndarray
 |      A 1-D array of real values. `y`'s length along the interpolation
 |      axis must be equal to the length of `x`. If N-D array, use `axis`
 |      parameter to select correct axis.
 |  axis : int, optional
 |      Axis in the y array corresponding to the x-coordinate values.
 |  extrapolate : bool, optional
 |      Whether to extrapolate to out-of-bounds points based on first
 |      and last intervals, or to return NaNs.
 |  
 |  Methods
 |  -------
 |  __call__
 |  derivative
 |  antiderivative
 |  roots
 |  
 |  See Also
 |  --------
 |  Akima1DInterpolator
 |  CubicSpline
 |  BPoly
 |  
 |  Notes
 |  -----
 |  The interpolator preserves monotonicity in the interpolation data and does
 |  not overshoot if the data is not smooth.
 |  
 |  The first derivatives are guaranteed to be continuous, but the second
 |  derivatives may jump at :math:`x_k`.
 |  
 |  Determines the derivatives at the points :math:`x_k`, :math:`f'_k`,
 |  by using PCHIP algorithm [1]_.
 |  
 |  Let :math:`h_k = x_{k+1} - x_k`, and  :math:`d_k = (y_{k+1} - y_k) / h_k`
 |  are the slopes at internal points :math:`x_k`.
 |  If the signs of :math:`d_k` and :math:`d_{k-1}` are different or either of
 |  them equals zero, then :math:`f'_k = 0`. Otherwise, it is given by the
 |  weighted harmonic mean
 |  
 |  .. math::
 |  
 |      \frac{w_1 + w_2}{f'_k} = \frac{w_1}{d_{k-1}} + \frac{w_2}{d_k}
 |  
 |  where :math:`w_1 = 2 h_k + h_{k-1}` and :math:`w_2 = h_k + 2 h_{k-1}`.
 |  
 |  The end slopes are set using a one-sided scheme [2]_.
 |  
 |  
 |  References
 |  ----------
 |  .. [1] F. N. Fritsch and R. E. Carlson, Monotone Piecewise Cubic Interpolation,
 |         SIAM J. Numer. Anal., 17(2), 238 (1980).
 |         :doi:`10.1137/0717021`.
 |  .. [2] see, e.g., C. Moler, Numerical Computing with Matlab, 2004.
 |         :doi:`10.1137/1.9780898717952`
 |  
 |  Method resolution order:
 |      PchipInterpolator
 |      scipy.interpolate.interpolate.BPoly
 |      scipy.interpolate.interpolate._PPolyBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, x, y, axis=0, extrapolate=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  roots(self)
 |      Return the roots of the interpolated function.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.interpolate.interpolate.BPoly:
 |  
 |  antiderivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the antiderivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of antiderivative to evaluate. Default is 1, i.e. compute
 |          the first integral. If negative, the derivative is returned.
 |      
 |      Returns
 |      -------
 |      bp : BPoly
 |          Piecewise polynomial of order k + nu representing the
 |          antiderivative of this polynomial.
 |      
 |      Notes
 |      -----
 |      If antiderivative is computed and ``self.extrapolate='periodic'``,
 |      it will be set to False for the returned instance. This is done because
 |      the antiderivative is no longer periodic and its correct evaluation
 |      outside of the initially given x interval is difficult.
 |  
 |  derivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the derivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of derivative to evaluate. Default is 1, i.e. compute the
 |          first derivative. If negative, the antiderivative is returned.
 |      
 |      Returns
 |      -------
 |      bp : BPoly
 |          Piecewise polynomial of order k - nu representing the derivative of
 |          this polynomial.
 |  
 |  extend(self, c, x, right=None)
 |      Add additional breakpoints and coefficients to the polynomial.
 |      
 |      Parameters
 |      ----------
 |      c : ndarray, size (k, m, ...)
 |          Additional coefficients for polynomials in intervals. Note that
 |          the first additional interval will be formed using one of the
 |          `self.x` end points.
 |      x : ndarray, size (m,)
 |          Additional breakpoints. Must be sorted in the same order as
 |          `self.x` and either to the right or to the left of the current
 |          breakpoints.
 |      right
 |          Deprecated argument. Has no effect.
 |      
 |          .. deprecated:: 0.19
 |  
 |  integrate(self, a, b, extrapolate=None)
 |      Compute a definite integral over a piecewise polynomial.
 |      
 |      Parameters
 |      ----------
 |      a : float
 |          Lower integration bound
 |      b : float
 |          Upper integration bound
 |      extrapolate : {bool, 'periodic', None}, optional
 |          Whether to extrapolate to out-of-bounds points based on first
 |          and last intervals, or to return NaNs. If 'periodic', periodic
 |          extrapolation is used. If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      array_like
 |          Definite integral of the piecewise polynomial over [a, b]
 |  
 |  ----------------------------------------------------------------------
 |  Class methods inherited from scipy.interpolate.interpolate.BPoly:
 |  
 |  from_derivatives(xi, yi, orders=None, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial in the Bernstein basis,
 |      compatible with the specified values and derivatives at breakpoints.
 |      
 |      Parameters
 |      ----------
 |      xi : array_like
 |          sorted 1D array of x-coordinates
 |      yi : array_like or list of array_likes
 |          ``yi[i][j]`` is the ``j``-th derivative known at ``xi[i]``
 |      orders : None or int or array_like of ints. Default: None.
 |          Specifies the degree of local polynomials. If not None, some
 |          derivatives are ignored.
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |      
 |      Notes
 |      -----
 |      If ``k`` derivatives are specified at a breakpoint ``x``, the
 |      constructed polynomial is exactly ``k`` times continuously
 |      differentiable at ``x``, unless the ``order`` is provided explicitly.
 |      In the latter case, the smoothness of the polynomial at
 |      the breakpoint is controlled by the ``order``.
 |      
 |      Deduces the number of derivatives to match at each end
 |      from ``order`` and the number of derivatives available. If
 |      possible it uses the same number of derivatives from
 |      each end; if the number is odd it tries to take the
 |      extra one from y2. In any case if not enough derivatives
 |      are available at one end or another it draws enough to
 |      make up the total from the other end.
 |      
 |      If the order is too high and not enough derivatives are available,
 |      an exception is raised.
 |      
 |      Examples
 |      --------
 |      
 |      >>> from scipy.interpolate import BPoly
 |      >>> BPoly.from_derivatives([0, 1], [[1, 2], [3, 4]])
 |      
 |      Creates a polynomial `f(x)` of degree 3, defined on `[0, 1]`
 |      such that `f(0) = 1, df/dx(0) = 2, f(1) = 3, df/dx(1) = 4`
 |      
 |      >>> BPoly.from_derivatives([0, 1, 2], [[0, 1], [0], [2]])
 |      
 |      Creates a piecewise polynomial `f(x)`, such that
 |      `f(0) = f(1) = 0`, `f(2) = 2`, and `df/dx(0) = 1`.
 |      Based on the number of derivatives provided, the order of the
 |      local polynomials is 2 on `[0, 1]` and 1 on `[1, 2]`.
 |      Notice that no restriction is imposed on the derivatives at
 |      `x = 1` and `x = 2`.
 |      
 |      Indeed, the explicit form of the polynomial is::
 |      
 |          f(x) = | x * (1 - x),  0 <= x < 1
 |                 | 2 * (x - 1),  1 <= x <= 2
 |      
 |      So that f'(1-0) = -1 and f'(1+0) = 2
 |  
 |  from_power_basis(pp, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial in Bernstein basis
 |      from a power basis polynomial.
 |      
 |      Parameters
 |      ----------
 |      pp : PPoly
 |          A piecewise polynomial in the power basis
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.interpolate.interpolate.BPoly:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.interpolate.interpolate._PPolyBase:
 |  
 |  __call__(self, x, nu=0, extrapolate=None)
 |      Evaluate the piecewise polynomial or its derivative.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      nu : int, optional
 |          Order of derivative to evaluate. Must be non-negative.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  ----------------------------------------------------------------------
 |  Class methods inherited from scipy.interpolate.interpolate._PPolyBase:
 |  
 |  construct_fast(c, x, extrapolate=None, axis=0) from builtins.type
 |      Construct the piecewise polynomial without making checks.
 |      
 |      Takes the same parameters as the constructor. Input arguments
 |      `c` and `x` must be arrays of the correct shape and type.  The
 |      `c` array can only be of dtypes float and complex, and `x`
 |      array must have dtype float.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.interpolate.interpolate._PPolyBase:
 |  
 |  axis
 |  
 |  c
 |  
 |  extrapolate
 |  
 |  x
",class,"('(self, x, y, axis=0, extrapolate=None)',)",scipy,1.1.0,scipy.interpolate._cubic.PchipInterpolator,interpolate._cubic,PchipInterpolator,"Python Library Documentation: class PchipInterpolator in module scipy.interpolate._cubic

class PchipInterpolator(scipy.interpolate.interpolate.BPoly)
 |  PCHIP 1-d monotonic cubic interpolation.
 |  
 |  `x` and `y` are arrays of values used to approximate some function f,
 |  with ``y = f(x)``. The interpolant uses monotonic cubic splines
 |  to find the value of new points. (PCHIP stands for Piecewise Cubic
 |  Hermite Interpolating Polynomial).
 |  
 |  Parameters
 |  ----------
 |  x : ndarray
 |      A 1-D array of monotonically increasing real values.  `x` cannot
 |      include duplicate values (otherwise f is overspecified)
 |  y : ndarray
 |      A 1-D array of real values. `y`'s length along the interpolation
 |      axis must be equal to the length of `x`. If N-D array, use `axis`
 |      parameter to select correct axis.
 |  axis : int, optional
 |      Axis in the y array corresponding to the x-coordinate values.
 |  extrapolate : bool, optional
 |      Whether to extrapolate to out-of-bounds points based on first
 |      and last intervals, or to return NaNs.
 |  
 |  Methods
 |  -------
 |  __call__
 |  derivative
 |  antiderivative
 |  roots
 |  
 |  See Also
 |  --------
 |  Akima1DInterpolator
 |  CubicSpline
 |  BPoly
 |  
 |  Notes
 |  -----
 |  The interpolator preserves monotonicity in the interpolation data and does
 |  not overshoot if the data is not smooth.
 |  
 |  The first derivatives are guaranteed to be continuous, but the second
 |  derivatives may jump at :math:`x_k`.
 |  
 |  Determines the derivatives at the points :math:`x_k`, :math:`f'_k`,
 |  by using PCHIP algorithm [1]_.
 |  
 |  Let :math:`h_k = x_{k+1} - x_k`, and  :math:`d_k = (y_{k+1} - y_k) / h_k`
 |  are the slopes at internal points :math:`x_k`.
 |  If the signs of :math:`d_k` and :math:`d_{k-1}` are different or either of
 |  them equals zero, then :math:`f'_k = 0`. Otherwise, it is given by the
 |  weighted harmonic mean
 |  
 |  .. math::
 |  
 |      \frac{w_1 + w_2}{f'_k} = \frac{w_1}{d_{k-1}} + \frac{w_2}{d_k}
 |  
 |  where :math:`w_1 = 2 h_k + h_{k-1}` and :math:`w_2 = h_k + 2 h_{k-1}`.
 |  
 |  The end slopes are set using a one-sided scheme [2]_.
 |  
 |  
 |  References
 |  ----------
 |  .. [1] F. N. Fritsch and R. E. Carlson, Monotone Piecewise Cubic Interpolation,
 |         SIAM J. Numer. Anal., 17(2), 238 (1980).
 |         :doi:`10.1137/0717021`.
 |  .. [2] see, e.g., C. Moler, Numerical Computing with Matlab, 2004.
 |         :doi:`10.1137/1.9780898717952`
 |  
 |  Method resolution order:
 |      PchipInterpolator
 |      scipy.interpolate.interpolate.BPoly
 |      scipy.interpolate.interpolate._PPolyBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, x, y, axis=0, extrapolate=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  roots(self)
 |      Return the roots of the interpolated function.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.interpolate.interpolate.BPoly:
 |  
 |  antiderivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the antiderivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of antiderivative to evaluate. Default is 1, i.e. compute
 |          the first integral. If negative, the derivative is returned.
 |      
 |      Returns
 |      -------
 |      bp : BPoly
 |          Piecewise polynomial of order k + nu representing the
 |          antiderivative of this polynomial.
 |      
 |      Notes
 |      -----
 |      If antiderivative is computed and ``self.extrapolate='periodic'``,
 |      it will be set to False for the returned instance. This is done because
 |      the antiderivative is no longer periodic and its correct evaluation
 |      outside of the initially given x interval is difficult.
 |  
 |  derivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the derivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of derivative to evaluate. Default is 1, i.e. compute the
 |          first derivative. If negative, the antiderivative is returned.
 |      
 |      Returns
 |      -------
 |      bp : BPoly
 |          Piecewise polynomial of order k - nu representing the derivative of
 |          this polynomial.
 |  
 |  extend(self, c, x, right=None)
 |      Add additional breakpoints and coefficients to the polynomial.
 |      
 |      Parameters
 |      ----------
 |      c : ndarray, size (k, m, ...)
 |          Additional coefficients for polynomials in intervals. Note that
 |          the first additional interval will be formed using one of the
 |          `self.x` end points.
 |      x : ndarray, size (m,)
 |          Additional breakpoints. Must be sorted in the same order as
 |          `self.x` and either to the right or to the left of the current
 |          breakpoints.
 |      right
 |          Deprecated argument. Has no effect.
 |      
 |          .. deprecated:: 0.19
 |  
 |  integrate(self, a, b, extrapolate=None)
 |      Compute a definite integral over a piecewise polynomial.
 |      
 |      Parameters
 |      ----------
 |      a : float
 |          Lower integration bound
 |      b : float
 |          Upper integration bound
 |      extrapolate : {bool, 'periodic', None}, optional
 |          Whether to extrapolate to out-of-bounds points based on first
 |          and last intervals, or to return NaNs. If 'periodic', periodic
 |          extrapolation is used. If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      array_like
 |          Definite integral of the piecewise polynomial over [a, b]
 |  
 |  ----------------------------------------------------------------------
 |  Class methods inherited from scipy.interpolate.interpolate.BPoly:
 |  
 |  from_derivatives(xi, yi, orders=None, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial in the Bernstein basis,
 |      compatible with the specified values and derivatives at breakpoints.
 |      
 |      Parameters
 |      ----------
 |      xi : array_like
 |          sorted 1D array of x-coordinates
 |      yi : array_like or list of array_likes
 |          ``yi[i][j]`` is the ``j``-th derivative known at ``xi[i]``
 |      orders : None or int or array_like of ints. Default: None.
 |          Specifies the degree of local polynomials. If not None, some
 |          derivatives are ignored.
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |      
 |      Notes
 |      -----
 |      If ``k`` derivatives are specified at a breakpoint ``x``, the
 |      constructed polynomial is exactly ``k`` times continuously
 |      differentiable at ``x``, unless the ``order`` is provided explicitly.
 |      In the latter case, the smoothness of the polynomial at
 |      the breakpoint is controlled by the ``order``.
 |      
 |      Deduces the number of derivatives to match at each end
 |      from ``order`` and the number of derivatives available. If
 |      possible it uses the same number of derivatives from
 |      each end; if the number is odd it tries to take the
 |      extra one from y2. In any case if not enough derivatives
 |      are available at one end or another it draws enough to
 |      make up the total from the other end.
 |      
 |      If the order is too high and not enough derivatives are available,
 |      an exception is raised.
 |      
 |      Examples
 |      --------
 |      
 |      >>> from scipy.interpolate import BPoly
 |      >>> BPoly.from_derivatives([0, 1], [[1, 2], [3, 4]])
 |      
 |      Creates a polynomial `f(x)` of degree 3, defined on `[0, 1]`
 |      such that `f(0) = 1, df/dx(0) = 2, f(1) = 3, df/dx(1) = 4`
 |      
 |      >>> BPoly.from_derivatives([0, 1, 2], [[0, 1], [0], [2]])
 |      
 |      Creates a piecewise polynomial `f(x)`, such that
 |      `f(0) = f(1) = 0`, `f(2) = 2`, and `df/dx(0) = 1`.
 |      Based on the number of derivatives provided, the order of the
 |      local polynomials is 2 on `[0, 1]` and 1 on `[1, 2]`.
 |      Notice that no restriction is imposed on the derivatives at
 |      `x = 1` and `x = 2`.
 |      
 |      Indeed, the explicit form of the polynomial is::
 |      
 |          f(x) = | x * (1 - x),  0 <= x < 1
 |                 | 2 * (x - 1),  1 <= x <= 2
 |      
 |      So that f'(1-0) = -1 and f'(1+0) = 2
 |  
 |  from_power_basis(pp, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial in Bernstein basis
 |      from a power basis polynomial.
 |      
 |      Parameters
 |      ----------
 |      pp : PPoly
 |          A piecewise polynomial in the power basis
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.interpolate.interpolate.BPoly:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.interpolate.interpolate._PPolyBase:
 |  
 |  __call__(self, x, nu=0, extrapolate=None)
 |      Evaluate the piecewise polynomial or its derivative.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      nu : int, optional
 |          Order of derivative to evaluate. Must be non-negative.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  ----------------------------------------------------------------------
 |  Class methods inherited from scipy.interpolate.interpolate._PPolyBase:
 |  
 |  construct_fast(c, x, extrapolate=None, axis=0) from builtins.type
 |      Construct the piecewise polynomial without making checks.
 |      
 |      Takes the same parameters as the constructor. Input arguments
 |      `c` and `x` must be arrays of the correct shape and type.  The
 |      `c` array can only be of dtypes float and complex, and `x`
 |      array must have dtype float.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.interpolate.interpolate._PPolyBase:
 |  
 |  axis
 |  
 |  c
 |  
 |  extrapolate
 |  
 |  x
",class,"('self', 'x', 'y', 'axis', 'extrapolate')","(nan, nan, nan, 0, None)","(nan, nan, nan, 'int', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, x, y, axis=0, extrapolate=None)',)"
scipy,1.1.0,scipy.interpolate._cubic.PchipInterpolator.construct_fast,interpolate._cubic.PchipInterpolator,construct_fast,"Python Library Documentation: method construct_fast in module scipy.interpolate.interpolate

construct_fast(c, x, extrapolate=None, axis=0) method of builtins.type instance
    Construct the piecewise polynomial without making checks.
    
    Takes the same parameters as the constructor. Input arguments
    `c` and `x` must be arrays of the correct shape and type.  The
    `c` array can only be of dtypes float and complex, and `x`
    array must have dtype float.
",method,"('(c, x, extrapolate=None, axis=0)',)",scipy,1.1.0,scipy.interpolate._cubic.PchipInterpolator.construct_fast,interpolate._cubic.PchipInterpolator,construct_fast,"Python Library Documentation: method construct_fast in module scipy.interpolate.interpolate

construct_fast(c, x, extrapolate=None, axis=0) method of builtins.type instance
    Construct the piecewise polynomial without making checks.
    
    Takes the same parameters as the constructor. Input arguments
    `c` and `x` must be arrays of the correct shape and type.  The
    `c` array can only be of dtypes float and complex, and `x`
    array must have dtype float.
",method,"('cls', 'c', 'x', 'extrapolate', 'axis')","(nan, nan, nan, None, 0)","(nan, nan, nan, 'NoneType', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(c, x, extrapolate=None, axis=0)',)"
scipy,1.1.0,scipy.interpolate._cubic.PchipInterpolator.from_derivatives,interpolate._cubic.PchipInterpolator,from_derivatives,"Python Library Documentation: method from_derivatives in module scipy.interpolate.interpolate

from_derivatives(xi, yi, orders=None, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial in the Bernstein basis,
    compatible with the specified values and derivatives at breakpoints.
    
    Parameters
    ----------
    xi : array_like
        sorted 1D array of x-coordinates
    yi : array_like or list of array_likes
        ``yi[i][j]`` is the ``j``-th derivative known at ``xi[i]``
    orders : None or int or array_like of ints. Default: None.
        Specifies the degree of local polynomials. If not None, some
        derivatives are ignored.
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
    
    Notes
    -----
    If ``k`` derivatives are specified at a breakpoint ``x``, the
    constructed polynomial is exactly ``k`` times continuously
    differentiable at ``x``, unless the ``order`` is provided explicitly.
    In the latter case, the smoothness of the polynomial at
    the breakpoint is controlled by the ``order``.
    
    Deduces the number of derivatives to match at each end
    from ``order`` and the number of derivatives available. If
    possible it uses the same number of derivatives from
    each end; if the number is odd it tries to take the
    extra one from y2. In any case if not enough derivatives
    are available at one end or another it draws enough to
    make up the total from the other end.
    
    If the order is too high and not enough derivatives are available,
    an exception is raised.
    
    Examples
    --------
    
    >>> from scipy.interpolate import BPoly
    >>> BPoly.from_derivatives([0, 1], [[1, 2], [3, 4]])
    
    Creates a polynomial `f(x)` of degree 3, defined on `[0, 1]`
    such that `f(0) = 1, df/dx(0) = 2, f(1) = 3, df/dx(1) = 4`
    
    >>> BPoly.from_derivatives([0, 1, 2], [[0, 1], [0], [2]])
    
    Creates a piecewise polynomial `f(x)`, such that
    `f(0) = f(1) = 0`, `f(2) = 2`, and `df/dx(0) = 1`.
    Based on the number of derivatives provided, the order of the
    local polynomials is 2 on `[0, 1]` and 1 on `[1, 2]`.
    Notice that no restriction is imposed on the derivatives at
    `x = 1` and `x = 2`.
    
    Indeed, the explicit form of the polynomial is::
    
        f(x) = | x * (1 - x),  0 <= x < 1
               | 2 * (x - 1),  1 <= x <= 2
    
    So that f'(1-0) = -1 and f'(1+0) = 2
",method,"('(xi, yi, orders=None, extrapolate=None)',)",scipy,1.1.0,scipy.interpolate._cubic.PchipInterpolator.from_derivatives,interpolate._cubic.PchipInterpolator,from_derivatives,"Python Library Documentation: method from_derivatives in module scipy.interpolate.interpolate

from_derivatives(xi, yi, orders=None, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial in the Bernstein basis,
    compatible with the specified values and derivatives at breakpoints.
    
    Parameters
    ----------
    xi : array_like
        sorted 1D array of x-coordinates
    yi : array_like or list of array_likes
        ``yi[i][j]`` is the ``j``-th derivative known at ``xi[i]``
    orders : None or int or array_like of ints. Default: None.
        Specifies the degree of local polynomials. If not None, some
        derivatives are ignored.
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
    
    Notes
    -----
    If ``k`` derivatives are specified at a breakpoint ``x``, the
    constructed polynomial is exactly ``k`` times continuously
    differentiable at ``x``, unless the ``order`` is provided explicitly.
    In the latter case, the smoothness of the polynomial at
    the breakpoint is controlled by the ``order``.
    
    Deduces the number of derivatives to match at each end
    from ``order`` and the number of derivatives available. If
    possible it uses the same number of derivatives from
    each end; if the number is odd it tries to take the
    extra one from y2. In any case if not enough derivatives
    are available at one end or another it draws enough to
    make up the total from the other end.
    
    If the order is too high and not enough derivatives are available,
    an exception is raised.
    
    Examples
    --------
    
    >>> from scipy.interpolate import BPoly
    >>> BPoly.from_derivatives([0, 1], [[1, 2], [3, 4]])
    
    Creates a polynomial `f(x)` of degree 3, defined on `[0, 1]`
    such that `f(0) = 1, df/dx(0) = 2, f(1) = 3, df/dx(1) = 4`
    
    >>> BPoly.from_derivatives([0, 1, 2], [[0, 1], [0], [2]])
    
    Creates a piecewise polynomial `f(x)`, such that
    `f(0) = f(1) = 0`, `f(2) = 2`, and `df/dx(0) = 1`.
    Based on the number of derivatives provided, the order of the
    local polynomials is 2 on `[0, 1]` and 1 on `[1, 2]`.
    Notice that no restriction is imposed on the derivatives at
    `x = 1` and `x = 2`.
    
    Indeed, the explicit form of the polynomial is::
    
        f(x) = | x * (1 - x),  0 <= x < 1
               | 2 * (x - 1),  1 <= x <= 2
    
    So that f'(1-0) = -1 and f'(1+0) = 2
",method,"('cls', 'xi', 'yi', 'orders', 'extrapolate')","(nan, nan, nan, None, None)","(nan, nan, nan, 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(xi, yi, orders=None, extrapolate=None)',)"
scipy,1.1.0,scipy.interpolate._cubic.PchipInterpolator.from_power_basis,interpolate._cubic.PchipInterpolator,from_power_basis,"Python Library Documentation: method from_power_basis in module scipy.interpolate.interpolate

from_power_basis(pp, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial in Bernstein basis
    from a power basis polynomial.
    
    Parameters
    ----------
    pp : PPoly
        A piecewise polynomial in the power basis
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
",method,"('(pp, extrapolate=None)',)",scipy,1.1.0,scipy.interpolate._cubic.PchipInterpolator.from_power_basis,interpolate._cubic.PchipInterpolator,from_power_basis,"Python Library Documentation: method from_power_basis in module scipy.interpolate.interpolate

from_power_basis(pp, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial in Bernstein basis
    from a power basis polynomial.
    
    Parameters
    ----------
    pp : PPoly
        A piecewise polynomial in the power basis
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
",method,"('cls', 'pp', 'extrapolate')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(pp, extrapolate=None)',)"
scipy,1.1.0,scipy.interpolate._cubic._asarray_validated,interpolate._cubic,_asarray_validated,"Python Library Documentation: function _asarray_validated in module scipy._lib._util

_asarray_validated(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)
    Helper function for scipy argument validation.
    
    Many scipy linear algebra functions do support arbitrary array-like
    input arguments.  Examples of commonly unsupported inputs include
    matrices containing inf/nan, sparse matrix representations, and
    matrices with complicated elements.
    
    Parameters
    ----------
    a : array_like
        The array-like input.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default: True
    sparse_ok : bool, optional
        True if scipy sparse matrices are allowed.
    objects_ok : bool, optional
        True if arrays with dype('O') are allowed.
    mask_ok : bool, optional
        True if masked arrays are allowed.
    as_inexact : bool, optional
        True to convert the input array to a np.inexact dtype.
    
    Returns
    -------
    ret : ndarray
        The converted validated array.
",function,"('(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)',)",scipy,1.1.0,scipy.interpolate._cubic._asarray_validated,interpolate._cubic,_asarray_validated,"Python Library Documentation: function _asarray_validated in module scipy._lib._util

_asarray_validated(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)
    Helper function for scipy argument validation.
    
    Many scipy linear algebra functions do support arbitrary array-like
    input arguments.  Examples of commonly unsupported inputs include
    matrices containing inf/nan, sparse matrix representations, and
    matrices with complicated elements.
    
    Parameters
    ----------
    a : array_like
        The array-like input.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default: True
    sparse_ok : bool, optional
        True if scipy sparse matrices are allowed.
    objects_ok : bool, optional
        True if arrays with dype('O') are allowed.
    mask_ok : bool, optional
        True if masked arrays are allowed.
    as_inexact : bool, optional
        True to convert the input array to a np.inexact dtype.
    
    Returns
    -------
    ret : ndarray
        The converted validated array.
",function,"('a', 'check_finite', 'sparse_ok', 'objects_ok', 'mask_ok', 'as_inexact')","(nan, True, False, False, False, False)","(nan, 'bool', 'bool', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)',)"
scipy,1.1.0,scipy.interpolate._cubic._isscalar,interpolate._cubic,_isscalar,"Python Library Documentation: function _isscalar in module scipy.interpolate.polyint

_isscalar(x)
    Check whether x is if a scalar type, or 0-dim
",function,"('(x)',)",scipy,1.1.0,scipy.interpolate._cubic._isscalar,interpolate._cubic,_isscalar,"Python Library Documentation: function _isscalar in module scipy.interpolate.polyint

_isscalar(x)
    Check whether x is if a scalar type, or 0-dim
",function,"('x',)","(nan,)","(nan,)","('arg_info',)","('(x)',)"
scipy,1.1.0,scipy.interpolate._cubic.pchip,interpolate._cubic,PchipInterpolator,"Python Library Documentation: class PchipInterpolator in module scipy.interpolate._cubic

class PchipInterpolator(scipy.interpolate.interpolate.BPoly)
 |  PCHIP 1-d monotonic cubic interpolation.
 |  
 |  `x` and `y` are arrays of values used to approximate some function f,
 |  with ``y = f(x)``. The interpolant uses monotonic cubic splines
 |  to find the value of new points. (PCHIP stands for Piecewise Cubic
 |  Hermite Interpolating Polynomial).
 |  
 |  Parameters
 |  ----------
 |  x : ndarray
 |      A 1-D array of monotonically increasing real values.  `x` cannot
 |      include duplicate values (otherwise f is overspecified)
 |  y : ndarray
 |      A 1-D array of real values. `y`'s length along the interpolation
 |      axis must be equal to the length of `x`. If N-D array, use `axis`
 |      parameter to select correct axis.
 |  axis : int, optional
 |      Axis in the y array corresponding to the x-coordinate values.
 |  extrapolate : bool, optional
 |      Whether to extrapolate to out-of-bounds points based on first
 |      and last intervals, or to return NaNs.
 |  
 |  Methods
 |  -------
 |  __call__
 |  derivative
 |  antiderivative
 |  roots
 |  
 |  See Also
 |  --------
 |  Akima1DInterpolator
 |  CubicSpline
 |  BPoly
 |  
 |  Notes
 |  -----
 |  The interpolator preserves monotonicity in the interpolation data and does
 |  not overshoot if the data is not smooth.
 |  
 |  The first derivatives are guaranteed to be continuous, but the second
 |  derivatives may jump at :math:`x_k`.
 |  
 |  Determines the derivatives at the points :math:`x_k`, :math:`f'_k`,
 |  by using PCHIP algorithm [1]_.
 |  
 |  Let :math:`h_k = x_{k+1} - x_k`, and  :math:`d_k = (y_{k+1} - y_k) / h_k`
 |  are the slopes at internal points :math:`x_k`.
 |  If the signs of :math:`d_k` and :math:`d_{k-1}` are different or either of
 |  them equals zero, then :math:`f'_k = 0`. Otherwise, it is given by the
 |  weighted harmonic mean
 |  
 |  .. math::
 |  
 |      \frac{w_1 + w_2}{f'_k} = \frac{w_1}{d_{k-1}} + \frac{w_2}{d_k}
 |  
 |  where :math:`w_1 = 2 h_k + h_{k-1}` and :math:`w_2 = h_k + 2 h_{k-1}`.
 |  
 |  The end slopes are set using a one-sided scheme [2]_.
 |  
 |  
 |  References
 |  ----------
 |  .. [1] F. N. Fritsch and R. E. Carlson, Monotone Piecewise Cubic Interpolation,
 |         SIAM J. Numer. Anal., 17(2), 238 (1980).
 |         :doi:`10.1137/0717021`.
 |  .. [2] see, e.g., C. Moler, Numerical Computing with Matlab, 2004.
 |         :doi:`10.1137/1.9780898717952`
 |  
 |  Method resolution order:
 |      PchipInterpolator
 |      scipy.interpolate.interpolate.BPoly
 |      scipy.interpolate.interpolate._PPolyBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, x, y, axis=0, extrapolate=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  roots(self)
 |      Return the roots of the interpolated function.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.interpolate.interpolate.BPoly:
 |  
 |  antiderivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the antiderivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of antiderivative to evaluate. Default is 1, i.e. compute
 |          the first integral. If negative, the derivative is returned.
 |      
 |      Returns
 |      -------
 |      bp : BPoly
 |          Piecewise polynomial of order k + nu representing the
 |          antiderivative of this polynomial.
 |      
 |      Notes
 |      -----
 |      If antiderivative is computed and ``self.extrapolate='periodic'``,
 |      it will be set to False for the returned instance. This is done because
 |      the antiderivative is no longer periodic and its correct evaluation
 |      outside of the initially given x interval is difficult.
 |  
 |  derivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the derivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of derivative to evaluate. Default is 1, i.e. compute the
 |          first derivative. If negative, the antiderivative is returned.
 |      
 |      Returns
 |      -------
 |      bp : BPoly
 |          Piecewise polynomial of order k - nu representing the derivative of
 |          this polynomial.
 |  
 |  extend(self, c, x, right=None)
 |      Add additional breakpoints and coefficients to the polynomial.
 |      
 |      Parameters
 |      ----------
 |      c : ndarray, size (k, m, ...)
 |          Additional coefficients for polynomials in intervals. Note that
 |          the first additional interval will be formed using one of the
 |          `self.x` end points.
 |      x : ndarray, size (m,)
 |          Additional breakpoints. Must be sorted in the same order as
 |          `self.x` and either to the right or to the left of the current
 |          breakpoints.
 |      right
 |          Deprecated argument. Has no effect.
 |      
 |          .. deprecated:: 0.19
 |  
 |  integrate(self, a, b, extrapolate=None)
 |      Compute a definite integral over a piecewise polynomial.
 |      
 |      Parameters
 |      ----------
 |      a : float
 |          Lower integration bound
 |      b : float
 |          Upper integration bound
 |      extrapolate : {bool, 'periodic', None}, optional
 |          Whether to extrapolate to out-of-bounds points based on first
 |          and last intervals, or to return NaNs. If 'periodic', periodic
 |          extrapolation is used. If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      array_like
 |          Definite integral of the piecewise polynomial over [a, b]
 |  
 |  ----------------------------------------------------------------------
 |  Class methods inherited from scipy.interpolate.interpolate.BPoly:
 |  
 |  from_derivatives(xi, yi, orders=None, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial in the Bernstein basis,
 |      compatible with the specified values and derivatives at breakpoints.
 |      
 |      Parameters
 |      ----------
 |      xi : array_like
 |          sorted 1D array of x-coordinates
 |      yi : array_like or list of array_likes
 |          ``yi[i][j]`` is the ``j``-th derivative known at ``xi[i]``
 |      orders : None or int or array_like of ints. Default: None.
 |          Specifies the degree of local polynomials. If not None, some
 |          derivatives are ignored.
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |      
 |      Notes
 |      -----
 |      If ``k`` derivatives are specified at a breakpoint ``x``, the
 |      constructed polynomial is exactly ``k`` times continuously
 |      differentiable at ``x``, unless the ``order`` is provided explicitly.
 |      In the latter case, the smoothness of the polynomial at
 |      the breakpoint is controlled by the ``order``.
 |      
 |      Deduces the number of derivatives to match at each end
 |      from ``order`` and the number of derivatives available. If
 |      possible it uses the same number of derivatives from
 |      each end; if the number is odd it tries to take the
 |      extra one from y2. In any case if not enough derivatives
 |      are available at one end or another it draws enough to
 |      make up the total from the other end.
 |      
 |      If the order is too high and not enough derivatives are available,
 |      an exception is raised.
 |      
 |      Examples
 |      --------
 |      
 |      >>> from scipy.interpolate import BPoly
 |      >>> BPoly.from_derivatives([0, 1], [[1, 2], [3, 4]])
 |      
 |      Creates a polynomial `f(x)` of degree 3, defined on `[0, 1]`
 |      such that `f(0) = 1, df/dx(0) = 2, f(1) = 3, df/dx(1) = 4`
 |      
 |      >>> BPoly.from_derivatives([0, 1, 2], [[0, 1], [0], [2]])
 |      
 |      Creates a piecewise polynomial `f(x)`, such that
 |      `f(0) = f(1) = 0`, `f(2) = 2`, and `df/dx(0) = 1`.
 |      Based on the number of derivatives provided, the order of the
 |      local polynomials is 2 on `[0, 1]` and 1 on `[1, 2]`.
 |      Notice that no restriction is imposed on the derivatives at
 |      `x = 1` and `x = 2`.
 |      
 |      Indeed, the explicit form of the polynomial is::
 |      
 |          f(x) = | x * (1 - x),  0 <= x < 1
 |                 | 2 * (x - 1),  1 <= x <= 2
 |      
 |      So that f'(1-0) = -1 and f'(1+0) = 2
 |  
 |  from_power_basis(pp, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial in Bernstein basis
 |      from a power basis polynomial.
 |      
 |      Parameters
 |      ----------
 |      pp : PPoly
 |          A piecewise polynomial in the power basis
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.interpolate.interpolate.BPoly:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.interpolate.interpolate._PPolyBase:
 |  
 |  __call__(self, x, nu=0, extrapolate=None)
 |      Evaluate the piecewise polynomial or its derivative.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      nu : int, optional
 |          Order of derivative to evaluate. Must be non-negative.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  ----------------------------------------------------------------------
 |  Class methods inherited from scipy.interpolate.interpolate._PPolyBase:
 |  
 |  construct_fast(c, x, extrapolate=None, axis=0) from builtins.type
 |      Construct the piecewise polynomial without making checks.
 |      
 |      Takes the same parameters as the constructor. Input arguments
 |      `c` and `x` must be arrays of the correct shape and type.  The
 |      `c` array can only be of dtypes float and complex, and `x`
 |      array must have dtype float.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.interpolate.interpolate._PPolyBase:
 |  
 |  axis
 |  
 |  c
 |  
 |  extrapolate
 |  
 |  x
",class,"('(self, x, y, axis=0, extrapolate=None)',)",scipy,1.1.0,scipy.interpolate._cubic.pchip,interpolate._cubic,PchipInterpolator,"Python Library Documentation: class PchipInterpolator in module scipy.interpolate._cubic

class PchipInterpolator(scipy.interpolate.interpolate.BPoly)
 |  PCHIP 1-d monotonic cubic interpolation.
 |  
 |  `x` and `y` are arrays of values used to approximate some function f,
 |  with ``y = f(x)``. The interpolant uses monotonic cubic splines
 |  to find the value of new points. (PCHIP stands for Piecewise Cubic
 |  Hermite Interpolating Polynomial).
 |  
 |  Parameters
 |  ----------
 |  x : ndarray
 |      A 1-D array of monotonically increasing real values.  `x` cannot
 |      include duplicate values (otherwise f is overspecified)
 |  y : ndarray
 |      A 1-D array of real values. `y`'s length along the interpolation
 |      axis must be equal to the length of `x`. If N-D array, use `axis`
 |      parameter to select correct axis.
 |  axis : int, optional
 |      Axis in the y array corresponding to the x-coordinate values.
 |  extrapolate : bool, optional
 |      Whether to extrapolate to out-of-bounds points based on first
 |      and last intervals, or to return NaNs.
 |  
 |  Methods
 |  -------
 |  __call__
 |  derivative
 |  antiderivative
 |  roots
 |  
 |  See Also
 |  --------
 |  Akima1DInterpolator
 |  CubicSpline
 |  BPoly
 |  
 |  Notes
 |  -----
 |  The interpolator preserves monotonicity in the interpolation data and does
 |  not overshoot if the data is not smooth.
 |  
 |  The first derivatives are guaranteed to be continuous, but the second
 |  derivatives may jump at :math:`x_k`.
 |  
 |  Determines the derivatives at the points :math:`x_k`, :math:`f'_k`,
 |  by using PCHIP algorithm [1]_.
 |  
 |  Let :math:`h_k = x_{k+1} - x_k`, and  :math:`d_k = (y_{k+1} - y_k) / h_k`
 |  are the slopes at internal points :math:`x_k`.
 |  If the signs of :math:`d_k` and :math:`d_{k-1}` are different or either of
 |  them equals zero, then :math:`f'_k = 0`. Otherwise, it is given by the
 |  weighted harmonic mean
 |  
 |  .. math::
 |  
 |      \frac{w_1 + w_2}{f'_k} = \frac{w_1}{d_{k-1}} + \frac{w_2}{d_k}
 |  
 |  where :math:`w_1 = 2 h_k + h_{k-1}` and :math:`w_2 = h_k + 2 h_{k-1}`.
 |  
 |  The end slopes are set using a one-sided scheme [2]_.
 |  
 |  
 |  References
 |  ----------
 |  .. [1] F. N. Fritsch and R. E. Carlson, Monotone Piecewise Cubic Interpolation,
 |         SIAM J. Numer. Anal., 17(2), 238 (1980).
 |         :doi:`10.1137/0717021`.
 |  .. [2] see, e.g., C. Moler, Numerical Computing with Matlab, 2004.
 |         :doi:`10.1137/1.9780898717952`
 |  
 |  Method resolution order:
 |      PchipInterpolator
 |      scipy.interpolate.interpolate.BPoly
 |      scipy.interpolate.interpolate._PPolyBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, x, y, axis=0, extrapolate=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  roots(self)
 |      Return the roots of the interpolated function.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.interpolate.interpolate.BPoly:
 |  
 |  antiderivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the antiderivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of antiderivative to evaluate. Default is 1, i.e. compute
 |          the first integral. If negative, the derivative is returned.
 |      
 |      Returns
 |      -------
 |      bp : BPoly
 |          Piecewise polynomial of order k + nu representing the
 |          antiderivative of this polynomial.
 |      
 |      Notes
 |      -----
 |      If antiderivative is computed and ``self.extrapolate='periodic'``,
 |      it will be set to False for the returned instance. This is done because
 |      the antiderivative is no longer periodic and its correct evaluation
 |      outside of the initially given x interval is difficult.
 |  
 |  derivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the derivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of derivative to evaluate. Default is 1, i.e. compute the
 |          first derivative. If negative, the antiderivative is returned.
 |      
 |      Returns
 |      -------
 |      bp : BPoly
 |          Piecewise polynomial of order k - nu representing the derivative of
 |          this polynomial.
 |  
 |  extend(self, c, x, right=None)
 |      Add additional breakpoints and coefficients to the polynomial.
 |      
 |      Parameters
 |      ----------
 |      c : ndarray, size (k, m, ...)
 |          Additional coefficients for polynomials in intervals. Note that
 |          the first additional interval will be formed using one of the
 |          `self.x` end points.
 |      x : ndarray, size (m,)
 |          Additional breakpoints. Must be sorted in the same order as
 |          `self.x` and either to the right or to the left of the current
 |          breakpoints.
 |      right
 |          Deprecated argument. Has no effect.
 |      
 |          .. deprecated:: 0.19
 |  
 |  integrate(self, a, b, extrapolate=None)
 |      Compute a definite integral over a piecewise polynomial.
 |      
 |      Parameters
 |      ----------
 |      a : float
 |          Lower integration bound
 |      b : float
 |          Upper integration bound
 |      extrapolate : {bool, 'periodic', None}, optional
 |          Whether to extrapolate to out-of-bounds points based on first
 |          and last intervals, or to return NaNs. If 'periodic', periodic
 |          extrapolation is used. If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      array_like
 |          Definite integral of the piecewise polynomial over [a, b]
 |  
 |  ----------------------------------------------------------------------
 |  Class methods inherited from scipy.interpolate.interpolate.BPoly:
 |  
 |  from_derivatives(xi, yi, orders=None, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial in the Bernstein basis,
 |      compatible with the specified values and derivatives at breakpoints.
 |      
 |      Parameters
 |      ----------
 |      xi : array_like
 |          sorted 1D array of x-coordinates
 |      yi : array_like or list of array_likes
 |          ``yi[i][j]`` is the ``j``-th derivative known at ``xi[i]``
 |      orders : None or int or array_like of ints. Default: None.
 |          Specifies the degree of local polynomials. If not None, some
 |          derivatives are ignored.
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |      
 |      Notes
 |      -----
 |      If ``k`` derivatives are specified at a breakpoint ``x``, the
 |      constructed polynomial is exactly ``k`` times continuously
 |      differentiable at ``x``, unless the ``order`` is provided explicitly.
 |      In the latter case, the smoothness of the polynomial at
 |      the breakpoint is controlled by the ``order``.
 |      
 |      Deduces the number of derivatives to match at each end
 |      from ``order`` and the number of derivatives available. If
 |      possible it uses the same number of derivatives from
 |      each end; if the number is odd it tries to take the
 |      extra one from y2. In any case if not enough derivatives
 |      are available at one end or another it draws enough to
 |      make up the total from the other end.
 |      
 |      If the order is too high and not enough derivatives are available,
 |      an exception is raised.
 |      
 |      Examples
 |      --------
 |      
 |      >>> from scipy.interpolate import BPoly
 |      >>> BPoly.from_derivatives([0, 1], [[1, 2], [3, 4]])
 |      
 |      Creates a polynomial `f(x)` of degree 3, defined on `[0, 1]`
 |      such that `f(0) = 1, df/dx(0) = 2, f(1) = 3, df/dx(1) = 4`
 |      
 |      >>> BPoly.from_derivatives([0, 1, 2], [[0, 1], [0], [2]])
 |      
 |      Creates a piecewise polynomial `f(x)`, such that
 |      `f(0) = f(1) = 0`, `f(2) = 2`, and `df/dx(0) = 1`.
 |      Based on the number of derivatives provided, the order of the
 |      local polynomials is 2 on `[0, 1]` and 1 on `[1, 2]`.
 |      Notice that no restriction is imposed on the derivatives at
 |      `x = 1` and `x = 2`.
 |      
 |      Indeed, the explicit form of the polynomial is::
 |      
 |          f(x) = | x * (1 - x),  0 <= x < 1
 |                 | 2 * (x - 1),  1 <= x <= 2
 |      
 |      So that f'(1-0) = -1 and f'(1+0) = 2
 |  
 |  from_power_basis(pp, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial in Bernstein basis
 |      from a power basis polynomial.
 |      
 |      Parameters
 |      ----------
 |      pp : PPoly
 |          A piecewise polynomial in the power basis
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.interpolate.interpolate.BPoly:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.interpolate.interpolate._PPolyBase:
 |  
 |  __call__(self, x, nu=0, extrapolate=None)
 |      Evaluate the piecewise polynomial or its derivative.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      nu : int, optional
 |          Order of derivative to evaluate. Must be non-negative.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  ----------------------------------------------------------------------
 |  Class methods inherited from scipy.interpolate.interpolate._PPolyBase:
 |  
 |  construct_fast(c, x, extrapolate=None, axis=0) from builtins.type
 |      Construct the piecewise polynomial without making checks.
 |      
 |      Takes the same parameters as the constructor. Input arguments
 |      `c` and `x` must be arrays of the correct shape and type.  The
 |      `c` array can only be of dtypes float and complex, and `x`
 |      array must have dtype float.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.interpolate.interpolate._PPolyBase:
 |  
 |  axis
 |  
 |  c
 |  
 |  extrapolate
 |  
 |  x
",class,"('self', 'x', 'y', 'axis', 'extrapolate')","(nan, nan, nan, 0, None)","(nan, nan, nan, 'int', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, x, y, axis=0, extrapolate=None)',)"
scipy,1.1.0,scipy.interpolate._cubic.pchip.construct_fast,interpolate._cubic.pchip,construct_fast,"Python Library Documentation: method construct_fast in module scipy.interpolate.interpolate

construct_fast(c, x, extrapolate=None, axis=0) method of builtins.type instance
    Construct the piecewise polynomial without making checks.
    
    Takes the same parameters as the constructor. Input arguments
    `c` and `x` must be arrays of the correct shape and type.  The
    `c` array can only be of dtypes float and complex, and `x`
    array must have dtype float.
",method,"('(c, x, extrapolate=None, axis=0)',)",scipy,1.1.0,scipy.interpolate._cubic.pchip.construct_fast,interpolate._cubic.pchip,construct_fast,"Python Library Documentation: method construct_fast in module scipy.interpolate.interpolate

construct_fast(c, x, extrapolate=None, axis=0) method of builtins.type instance
    Construct the piecewise polynomial without making checks.
    
    Takes the same parameters as the constructor. Input arguments
    `c` and `x` must be arrays of the correct shape and type.  The
    `c` array can only be of dtypes float and complex, and `x`
    array must have dtype float.
",method,"('cls', 'c', 'x', 'extrapolate', 'axis')","(nan, nan, nan, None, 0)","(nan, nan, nan, 'NoneType', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(c, x, extrapolate=None, axis=0)',)"
scipy,1.1.0,scipy.interpolate._cubic.pchip.from_derivatives,interpolate._cubic.pchip,from_derivatives,"Python Library Documentation: method from_derivatives in module scipy.interpolate.interpolate

from_derivatives(xi, yi, orders=None, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial in the Bernstein basis,
    compatible with the specified values and derivatives at breakpoints.
    
    Parameters
    ----------
    xi : array_like
        sorted 1D array of x-coordinates
    yi : array_like or list of array_likes
        ``yi[i][j]`` is the ``j``-th derivative known at ``xi[i]``
    orders : None or int or array_like of ints. Default: None.
        Specifies the degree of local polynomials. If not None, some
        derivatives are ignored.
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
    
    Notes
    -----
    If ``k`` derivatives are specified at a breakpoint ``x``, the
    constructed polynomial is exactly ``k`` times continuously
    differentiable at ``x``, unless the ``order`` is provided explicitly.
    In the latter case, the smoothness of the polynomial at
    the breakpoint is controlled by the ``order``.
    
    Deduces the number of derivatives to match at each end
    from ``order`` and the number of derivatives available. If
    possible it uses the same number of derivatives from
    each end; if the number is odd it tries to take the
    extra one from y2. In any case if not enough derivatives
    are available at one end or another it draws enough to
    make up the total from the other end.
    
    If the order is too high and not enough derivatives are available,
    an exception is raised.
    
    Examples
    --------
    
    >>> from scipy.interpolate import BPoly
    >>> BPoly.from_derivatives([0, 1], [[1, 2], [3, 4]])
    
    Creates a polynomial `f(x)` of degree 3, defined on `[0, 1]`
    such that `f(0) = 1, df/dx(0) = 2, f(1) = 3, df/dx(1) = 4`
    
    >>> BPoly.from_derivatives([0, 1, 2], [[0, 1], [0], [2]])
    
    Creates a piecewise polynomial `f(x)`, such that
    `f(0) = f(1) = 0`, `f(2) = 2`, and `df/dx(0) = 1`.
    Based on the number of derivatives provided, the order of the
    local polynomials is 2 on `[0, 1]` and 1 on `[1, 2]`.
    Notice that no restriction is imposed on the derivatives at
    `x = 1` and `x = 2`.
    
    Indeed, the explicit form of the polynomial is::
    
        f(x) = | x * (1 - x),  0 <= x < 1
               | 2 * (x - 1),  1 <= x <= 2
    
    So that f'(1-0) = -1 and f'(1+0) = 2
",method,"('(xi, yi, orders=None, extrapolate=None)',)",scipy,1.1.0,scipy.interpolate._cubic.pchip.from_derivatives,interpolate._cubic.pchip,from_derivatives,"Python Library Documentation: method from_derivatives in module scipy.interpolate.interpolate

from_derivatives(xi, yi, orders=None, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial in the Bernstein basis,
    compatible with the specified values and derivatives at breakpoints.
    
    Parameters
    ----------
    xi : array_like
        sorted 1D array of x-coordinates
    yi : array_like or list of array_likes
        ``yi[i][j]`` is the ``j``-th derivative known at ``xi[i]``
    orders : None or int or array_like of ints. Default: None.
        Specifies the degree of local polynomials. If not None, some
        derivatives are ignored.
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
    
    Notes
    -----
    If ``k`` derivatives are specified at a breakpoint ``x``, the
    constructed polynomial is exactly ``k`` times continuously
    differentiable at ``x``, unless the ``order`` is provided explicitly.
    In the latter case, the smoothness of the polynomial at
    the breakpoint is controlled by the ``order``.
    
    Deduces the number of derivatives to match at each end
    from ``order`` and the number of derivatives available. If
    possible it uses the same number of derivatives from
    each end; if the number is odd it tries to take the
    extra one from y2. In any case if not enough derivatives
    are available at one end or another it draws enough to
    make up the total from the other end.
    
    If the order is too high and not enough derivatives are available,
    an exception is raised.
    
    Examples
    --------
    
    >>> from scipy.interpolate import BPoly
    >>> BPoly.from_derivatives([0, 1], [[1, 2], [3, 4]])
    
    Creates a polynomial `f(x)` of degree 3, defined on `[0, 1]`
    such that `f(0) = 1, df/dx(0) = 2, f(1) = 3, df/dx(1) = 4`
    
    >>> BPoly.from_derivatives([0, 1, 2], [[0, 1], [0], [2]])
    
    Creates a piecewise polynomial `f(x)`, such that
    `f(0) = f(1) = 0`, `f(2) = 2`, and `df/dx(0) = 1`.
    Based on the number of derivatives provided, the order of the
    local polynomials is 2 on `[0, 1]` and 1 on `[1, 2]`.
    Notice that no restriction is imposed on the derivatives at
    `x = 1` and `x = 2`.
    
    Indeed, the explicit form of the polynomial is::
    
        f(x) = | x * (1 - x),  0 <= x < 1
               | 2 * (x - 1),  1 <= x <= 2
    
    So that f'(1-0) = -1 and f'(1+0) = 2
",method,"('cls', 'xi', 'yi', 'orders', 'extrapolate')","(nan, nan, nan, None, None)","(nan, nan, nan, 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(xi, yi, orders=None, extrapolate=None)',)"
scipy,1.1.0,scipy.interpolate._cubic.pchip.from_power_basis,interpolate._cubic.pchip,from_power_basis,"Python Library Documentation: method from_power_basis in module scipy.interpolate.interpolate

from_power_basis(pp, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial in Bernstein basis
    from a power basis polynomial.
    
    Parameters
    ----------
    pp : PPoly
        A piecewise polynomial in the power basis
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
",method,"('(pp, extrapolate=None)',)",scipy,1.1.0,scipy.interpolate._cubic.pchip.from_power_basis,interpolate._cubic.pchip,from_power_basis,"Python Library Documentation: method from_power_basis in module scipy.interpolate.interpolate

from_power_basis(pp, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial in Bernstein basis
    from a power basis polynomial.
    
    Parameters
    ----------
    pp : PPoly
        A piecewise polynomial in the power basis
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
",method,"('cls', 'pp', 'extrapolate')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(pp, extrapolate=None)',)"
scipy,1.1.0,scipy.interpolate._cubic.pchip_interpolate,interpolate._cubic,pchip_interpolate,"Python Library Documentation: function pchip_interpolate in module scipy.interpolate._cubic

pchip_interpolate(xi, yi, x, der=0, axis=0)
    Convenience function for pchip interpolation.
    xi and yi are arrays of values used to approximate some function f,
    with ``yi = f(xi)``.  The interpolant uses monotonic cubic splines
    to find the value of new points x and the derivatives there.
    
    See `PchipInterpolator` for details.
    
    Parameters
    ----------
    xi : array_like
        A sorted list of x-coordinates, of length N.
    yi :  array_like
        A 1-D array of real values.  `yi`'s length along the interpolation
        axis must be equal to the length of `xi`. If N-D array, use axis
        parameter to select correct axis.
    x : scalar or array_like
        Of length M.
    der : int or list, optional
        Derivatives to extract.  The 0-th derivative can be included to
        return the function value.
    axis : int, optional
        Axis in the yi array corresponding to the x-coordinate values.
    
    See Also
    --------
    PchipInterpolator
    
    Returns
    -------
    y : scalar or array_like
        The result, of length R or length M or M by R,
",function,"('(xi, yi, x, der=0, axis=0)',)",scipy,1.1.0,scipy.interpolate._cubic.pchip_interpolate,interpolate._cubic,pchip_interpolate,"Python Library Documentation: function pchip_interpolate in module scipy.interpolate._cubic

pchip_interpolate(xi, yi, x, der=0, axis=0)
    Convenience function for pchip interpolation.
    xi and yi are arrays of values used to approximate some function f,
    with ``yi = f(xi)``.  The interpolant uses monotonic cubic splines
    to find the value of new points x and the derivatives there.
    
    See `PchipInterpolator` for details.
    
    Parameters
    ----------
    xi : array_like
        A sorted list of x-coordinates, of length N.
    yi :  array_like
        A 1-D array of real values.  `yi`'s length along the interpolation
        axis must be equal to the length of `xi`. If N-D array, use axis
        parameter to select correct axis.
    x : scalar or array_like
        Of length M.
    der : int or list, optional
        Derivatives to extract.  The 0-th derivative can be included to
        return the function value.
    axis : int, optional
        Axis in the yi array corresponding to the x-coordinate values.
    
    See Also
    --------
    PchipInterpolator
    
    Returns
    -------
    y : scalar or array_like
        The result, of length R or length M or M by R,
",function,"('xi', 'yi', 'x', 'der', 'axis')","(nan, nan, nan, 0, 0)","(nan, nan, nan, 'int', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(xi, yi, x, der=0, axis=0)',)"
scipy,1.1.0,scipy.interpolate._cubic.solve,interpolate._cubic,solve,"Python Library Documentation: function solve in module scipy.linalg.basic

solve(a, b, sym_pos=False, lower=False, overwrite_a=False, overwrite_b=False, debug=None, check_finite=True, assume_a='gen', transposed=False)
    Solves the linear equation set ``a * x = b`` for the unknown ``x``
    for square ``a`` matrix.
    
    If the data matrix is known to be a particular type then supplying the
    corresponding string to ``assume_a`` key chooses the dedicated solver.
    The available options are
    
    ===================  ========
     generic matrix       'gen'
     symmetric            'sym'
     hermitian            'her'
     positive definite    'pos'
    ===================  ========
    
    If omitted, ``'gen'`` is the default structure.
    
    The datatype of the arrays define which solver is called regardless
    of the values. In other words, even when the complex array entries have
    precisely zero imaginary parts, the complex solver will be called based
    on the data type of the array.
    
    Parameters
    ----------
    a : (N, N) array_like
        Square input data
    b : (N, NRHS) array_like
        Input data for the right hand side.
    sym_pos : bool, optional
        Assume `a` is symmetric and positive definite. This key is deprecated
        and assume_a = 'pos' keyword is recommended instead. The functionality
        is the same. It will be removed in the future.
    lower : bool, optional
        If True, only the data contained in the lower triangle of `a`. Default
        is to use upper triangle. (ignored for ``'gen'``)
    overwrite_a : bool, optional
        Allow overwriting data in `a` (may enhance performance).
        Default is False.
    overwrite_b : bool, optional
        Allow overwriting data in `b` (may enhance performance).
        Default is False.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    assume_a : str, optional
        Valid entries are explained above.
    transposed: bool, optional
        If True, ``a^T x = b`` for real matrices, raises `NotImplementedError`
        for complex matrices (only for True).
    
    Returns
    -------
    x : (N, NRHS) ndarray
        The solution array.
    
    Raises
    ------
    ValueError
        If size mismatches detected or input a is not square.
    LinAlgError
        If the matrix is singular.
    LinAlgWarning
        If an ill-conditioned input a is detected.
    NotImplementedError
        If transposed is True and input a is a complex matrix.
    
    Examples
    --------
    Given `a` and `b`, solve for `x`:
    
    >>> a = np.array([[3, 2, 0], [1, -1, 0], [0, 5, 1]])
    >>> b = np.array([2, 4, -1])
    >>> from scipy import linalg
    >>> x = linalg.solve(a, b)
    >>> x
    array([ 2., -2.,  9.])
    >>> np.dot(a, x) == b
    array([ True,  True,  True], dtype=bool)
    
    Notes
    -----
    If the input b matrix is a 1D array with N elements, when supplied
    together with an NxN input a, it is assumed as a valid column vector
    despite the apparent size mismatch. This is compatible with the
    numpy.dot() behavior and the returned result is still 1D array.
    
    The generic, symmetric, hermitian and positive definite solutions are
    obtained via calling ?GESV, ?SYSV, ?HESV, and ?POSV routines of
    LAPACK respectively.
",function,"(""(a, b, sym_pos=False, lower=False, overwrite_a=False, overwrite_b=False, debug=None, check_finite=True, assume_a='gen', transposed=False)"",)",scipy,1.1.0,scipy.interpolate._cubic.solve,interpolate._cubic,solve,"Python Library Documentation: function solve in module scipy.linalg.basic

solve(a, b, sym_pos=False, lower=False, overwrite_a=False, overwrite_b=False, debug=None, check_finite=True, assume_a='gen', transposed=False)
    Solves the linear equation set ``a * x = b`` for the unknown ``x``
    for square ``a`` matrix.
    
    If the data matrix is known to be a particular type then supplying the
    corresponding string to ``assume_a`` key chooses the dedicated solver.
    The available options are
    
    ===================  ========
     generic matrix       'gen'
     symmetric            'sym'
     hermitian            'her'
     positive definite    'pos'
    ===================  ========
    
    If omitted, ``'gen'`` is the default structure.
    
    The datatype of the arrays define which solver is called regardless
    of the values. In other words, even when the complex array entries have
    precisely zero imaginary parts, the complex solver will be called based
    on the data type of the array.
    
    Parameters
    ----------
    a : (N, N) array_like
        Square input data
    b : (N, NRHS) array_like
        Input data for the right hand side.
    sym_pos : bool, optional
        Assume `a` is symmetric and positive definite. This key is deprecated
        and assume_a = 'pos' keyword is recommended instead. The functionality
        is the same. It will be removed in the future.
    lower : bool, optional
        If True, only the data contained in the lower triangle of `a`. Default
        is to use upper triangle. (ignored for ``'gen'``)
    overwrite_a : bool, optional
        Allow overwriting data in `a` (may enhance performance).
        Default is False.
    overwrite_b : bool, optional
        Allow overwriting data in `b` (may enhance performance).
        Default is False.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    assume_a : str, optional
        Valid entries are explained above.
    transposed: bool, optional
        If True, ``a^T x = b`` for real matrices, raises `NotImplementedError`
        for complex matrices (only for True).
    
    Returns
    -------
    x : (N, NRHS) ndarray
        The solution array.
    
    Raises
    ------
    ValueError
        If size mismatches detected or input a is not square.
    LinAlgError
        If the matrix is singular.
    LinAlgWarning
        If an ill-conditioned input a is detected.
    NotImplementedError
        If transposed is True and input a is a complex matrix.
    
    Examples
    --------
    Given `a` and `b`, solve for `x`:
    
    >>> a = np.array([[3, 2, 0], [1, -1, 0], [0, 5, 1]])
    >>> b = np.array([2, 4, -1])
    >>> from scipy import linalg
    >>> x = linalg.solve(a, b)
    >>> x
    array([ 2., -2.,  9.])
    >>> np.dot(a, x) == b
    array([ True,  True,  True], dtype=bool)
    
    Notes
    -----
    If the input b matrix is a 1D array with N elements, when supplied
    together with an NxN input a, it is assumed as a valid column vector
    despite the apparent size mismatch. This is compatible with the
    numpy.dot() behavior and the returned result is still 1D array.
    
    The generic, symmetric, hermitian and positive definite solutions are
    obtained via calling ?GESV, ?SYSV, ?HESV, and ?POSV routines of
    LAPACK respectively.
",function,"('a', 'b', 'sym_pos', 'lower', 'overwrite_a', 'overwrite_b', 'debug', 'check_finite', 'assume_a', 'transposed')","(nan, nan, False, False, False, False, None, True, 'gen', False)","(nan, nan, 'bool', 'bool', 'bool', 'bool', 'NoneType', 'bool', 'str', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a, b, sym_pos=False, lower=False, overwrite_a=False, overwrite_b=False, debug=None, check_finite=True, assume_a='gen', transposed=False)"",)"
scipy,1.1.0,scipy.interpolate._cubic.solve_banded,interpolate._cubic,solve_banded,"Python Library Documentation: function solve_banded in module scipy.linalg.basic

solve_banded(l_and_u, ab, b, overwrite_ab=False, overwrite_b=False, debug=None, check_finite=True)
    Solve the equation a x = b for x, assuming a is banded matrix.
    
    The matrix a is stored in `ab` using the matrix diagonal ordered form::
    
        ab[u + i - j, j] == a[i,j]
    
    Example of `ab` (shape of a is (6,6), `u` =1, `l` =2)::
    
        *    a01  a12  a23  a34  a45
        a00  a11  a22  a33  a44  a55
        a10  a21  a32  a43  a54   *
        a20  a31  a42  a53   *    *
    
    Parameters
    ----------
    (l, u) : (integer, integer)
        Number of non-zero lower and upper diagonals
    ab : (`l` + `u` + 1, M) array_like
        Banded matrix
    b : (M,) or (M, K) array_like
        Right-hand side
    overwrite_ab : bool, optional
        Discard data in `ab` (may enhance performance)
    overwrite_b : bool, optional
        Discard data in `b` (may enhance performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : (M,) or (M, K) ndarray
        The solution to the system a x = b.  Returned shape depends on the
        shape of `b`.
    
    Examples
    --------
    Solve the banded system a x = b, where::
    
            [5  2 -1  0  0]       [0]
            [1  4  2 -1  0]       [1]
        a = [0  1  3  2 -1]   b = [2]
            [0  0  1  2  2]       [2]
            [0  0  0  1  1]       [3]
    
    There is one nonzero diagonal below the main diagonal (l = 1), and
    two above (u = 2).  The diagonal banded form of the matrix is::
    
             [*  * -1 -1 -1]
        ab = [*  2  2  2  2]
             [5  4  3  2  1]
             [1  1  1  1  *]
    
    >>> from scipy.linalg import solve_banded
    >>> ab = np.array([[0,  0, -1, -1, -1],
    ...                [0,  2,  2,  2,  2],
    ...                [5,  4,  3,  2,  1],
    ...                [1,  1,  1,  1,  0]])
    >>> b = np.array([0, 1, 2, 2, 3])
    >>> x = solve_banded((1, 2), ab, b)
    >>> x
    array([-2.37288136,  3.93220339, -4.        ,  4.3559322 , -1.3559322 ])
",function,"('(l_and_u, ab, b, overwrite_ab=False, overwrite_b=False, debug=None, check_finite=True)',)",scipy,1.1.0,scipy.interpolate._cubic.solve_banded,interpolate._cubic,solve_banded,"Python Library Documentation: function solve_banded in module scipy.linalg.basic

solve_banded(l_and_u, ab, b, overwrite_ab=False, overwrite_b=False, debug=None, check_finite=True)
    Solve the equation a x = b for x, assuming a is banded matrix.
    
    The matrix a is stored in `ab` using the matrix diagonal ordered form::
    
        ab[u + i - j, j] == a[i,j]
    
    Example of `ab` (shape of a is (6,6), `u` =1, `l` =2)::
    
        *    a01  a12  a23  a34  a45
        a00  a11  a22  a33  a44  a55
        a10  a21  a32  a43  a54   *
        a20  a31  a42  a53   *    *
    
    Parameters
    ----------
    (l, u) : (integer, integer)
        Number of non-zero lower and upper diagonals
    ab : (`l` + `u` + 1, M) array_like
        Banded matrix
    b : (M,) or (M, K) array_like
        Right-hand side
    overwrite_ab : bool, optional
        Discard data in `ab` (may enhance performance)
    overwrite_b : bool, optional
        Discard data in `b` (may enhance performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : (M,) or (M, K) ndarray
        The solution to the system a x = b.  Returned shape depends on the
        shape of `b`.
    
    Examples
    --------
    Solve the banded system a x = b, where::
    
            [5  2 -1  0  0]       [0]
            [1  4  2 -1  0]       [1]
        a = [0  1  3  2 -1]   b = [2]
            [0  0  1  2  2]       [2]
            [0  0  0  1  1]       [3]
    
    There is one nonzero diagonal below the main diagonal (l = 1), and
    two above (u = 2).  The diagonal banded form of the matrix is::
    
             [*  * -1 -1 -1]
        ab = [*  2  2  2  2]
             [5  4  3  2  1]
             [1  1  1  1  *]
    
    >>> from scipy.linalg import solve_banded
    >>> ab = np.array([[0,  0, -1, -1, -1],
    ...                [0,  2,  2,  2,  2],
    ...                [5,  4,  3,  2,  1],
    ...                [1,  1,  1,  1,  0]])
    >>> b = np.array([0, 1, 2, 2, 3])
    >>> x = solve_banded((1, 2), ab, b)
    >>> x
    array([-2.37288136,  3.93220339, -4.        ,  4.3559322 , -1.3559322 ])
",function,"('l_and_u', 'ab', 'b', 'overwrite_ab', 'overwrite_b', 'debug', 'check_finite')","(nan, nan, nan, False, False, None, True)","(nan, nan, nan, 'bool', 'bool', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(l_and_u, ab, b, overwrite_ab=False, overwrite_b=False, debug=None, check_finite=True)',)"
scipy,1.1.0,scipy.interpolate._fitpack_impl._intc_overflow,interpolate._fitpack_impl,_intc_overflow,"Python Library Documentation: function _intc_overflow in module scipy.interpolate._fitpack_impl

_intc_overflow(x, msg=None)
    Cast the value to an intc and raise an OverflowError if the value
    cannot fit.
",function,"('(x, msg=None)',)",scipy,1.1.0,scipy.interpolate._fitpack_impl._intc_overflow,interpolate._fitpack_impl,_intc_overflow,"Python Library Documentation: function _intc_overflow in module scipy.interpolate._fitpack_impl

_intc_overflow(x, msg=None)
    Cast the value to an intc and raise an OverflowError if the value
    cannot fit.
",function,"('x', 'msg')","(nan, None)","(nan, 'NoneType')","('arg_info', 'arg_info')","('(x, msg=None)',)"
scipy,1.1.0,scipy.interpolate._fitpack_impl.asarray,interpolate._fitpack_impl,asarray,"Python Library Documentation: function asarray in module numpy.core.numeric

asarray(a, dtype=None, order=None)
    Convert the input to an array.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
        Whether to use row-major (C-style) or
        column-major (Fortran-style) memory representation.
        Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray with matching dtype and order.  If `a` is a
        subclass of ndarray, a base class ndarray is returned.
    
    See Also
    --------
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    asarray_chkfinite : Similar function which checks input for NaNs and Infs.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array:
    
    >>> a = [1, 2]
    >>> np.asarray(a)
    array([1, 2])
    
    Existing arrays are not copied:
    
    >>> a = np.array([1, 2])
    >>> np.asarray(a) is a
    True
    
    If `dtype` is set, array is copied only if dtype does not match:
    
    >>> a = np.array([1, 2], dtype=np.float32)
    >>> np.asarray(a, dtype=np.float32) is a
    True
    >>> np.asarray(a, dtype=np.float64) is a
    False
    
    Contrary to `asanyarray`, ndarray subclasses are not passed through:
    
    >>> issubclass(np.matrix, np.ndarray)
    True
    >>> a = np.matrix([[1, 2]])
    >>> np.asarray(a) is a
    False
    >>> np.asanyarray(a) is a
    True
",function,"('(a, dtype=None, order=None)',)",scipy,1.1.0,scipy.interpolate._fitpack_impl.asarray,interpolate._fitpack_impl,asarray,"Python Library Documentation: function asarray in module numpy.core.numeric

asarray(a, dtype=None, order=None)
    Convert the input to an array.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
        Whether to use row-major (C-style) or
        column-major (Fortran-style) memory representation.
        Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray with matching dtype and order.  If `a` is a
        subclass of ndarray, a base class ndarray is returned.
    
    See Also
    --------
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    asarray_chkfinite : Similar function which checks input for NaNs and Infs.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array:
    
    >>> a = [1, 2]
    >>> np.asarray(a)
    array([1, 2])
    
    Existing arrays are not copied:
    
    >>> a = np.array([1, 2])
    >>> np.asarray(a) is a
    True
    
    If `dtype` is set, array is copied only if dtype does not match:
    
    >>> a = np.array([1, 2], dtype=np.float32)
    >>> np.asarray(a, dtype=np.float32) is a
    True
    >>> np.asarray(a, dtype=np.float64) is a
    False
    
    Contrary to `asanyarray`, ndarray subclasses are not passed through:
    
    >>> issubclass(np.matrix, np.ndarray)
    True
    >>> a = np.matrix([[1, 2]])
    >>> np.asarray(a) is a
    False
    >>> np.asanyarray(a) is a
    True
",function,"('a', 'dtype', 'order')","(nan, None, None)","(nan, 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(a, dtype=None, order=None)',)"
scipy,1.1.0,scipy.interpolate._fitpack_impl.atleast_1d,interpolate._fitpack_impl,atleast_1d,"Python Library Documentation: function atleast_1d in module numpy.core.shape_base

atleast_1d(*arys)
    Convert inputs to arrays with at least one dimension.
    
    Scalar inputs are converted to 1-dimensional arrays, whilst
    higher-dimensional inputs are preserved.
    
    Parameters
    ----------
    arys1, arys2, ... : array_like
        One or more input arrays.
    
    Returns
    -------
    ret : ndarray
        An array, or list of arrays, each with ``a.ndim >= 1``.
        Copies are made only if necessary.
    
    See Also
    --------
    atleast_2d, atleast_3d
    
    Examples
    --------
    >>> np.atleast_1d(1.0)
    array([ 1.])
    
    >>> x = np.arange(9.0).reshape(3,3)
    >>> np.atleast_1d(x)
    array([[ 0.,  1.,  2.],
           [ 3.,  4.,  5.],
           [ 6.,  7.,  8.]])
    >>> np.atleast_1d(x) is x
    True
    
    >>> np.atleast_1d(1, [3, 4])
    [array([1]), array([3, 4])]
",function,"('(*arys)',)",scipy,1.1.0,scipy.interpolate._fitpack_impl.atleast_1d,interpolate._fitpack_impl,atleast_1d,"Python Library Documentation: function atleast_1d in module numpy.core.shape_base

atleast_1d(*arys)
    Convert inputs to arrays with at least one dimension.
    
    Scalar inputs are converted to 1-dimensional arrays, whilst
    higher-dimensional inputs are preserved.
    
    Parameters
    ----------
    arys1, arys2, ... : array_like
        One or more input arrays.
    
    Returns
    -------
    ret : ndarray
        An array, or list of arrays, each with ``a.ndim >= 1``.
        Copies are made only if necessary.
    
    See Also
    --------
    atleast_2d, atleast_3d
    
    Examples
    --------
    >>> np.atleast_1d(1.0)
    array([ 1.])
    
    >>> x = np.arange(9.0).reshape(3,3)
    >>> np.atleast_1d(x)
    array([[ 0.,  1.,  2.],
           [ 3.,  4.,  5.],
           [ 6.,  7.,  8.]])
    >>> np.atleast_1d(x) is x
    True
    
    >>> np.atleast_1d(1, [3, 4])
    [array([1]), array([3, 4])]
",function,(),(),(),(),"('(*arys)',)"
scipy,1.1.0,scipy.interpolate._fitpack_impl.bisplev,interpolate._fitpack_impl,bisplev,"Python Library Documentation: function bisplev in module scipy.interpolate._fitpack_impl

bisplev(x, y, tck, dx=0, dy=0)
    Evaluate a bivariate B-spline and its derivatives.
    
    Return a rank-2 array of spline function values (or spline derivative
    values) at points given by the cross-product of the rank-1 arrays `x` and
    `y`.  In special cases, return an array or just a float if either `x` or
    `y` or both are floats.  Based on BISPEV from FITPACK.
    
    Parameters
    ----------
    x, y : ndarray
        Rank-1 arrays specifying the domain over which to evaluate the
        spline or its derivative.
    tck : tuple
        A sequence of length 5 returned by `bisplrep` containing the knot
        locations, the coefficients, and the degree of the spline:
        [tx, ty, c, kx, ky].
    dx, dy : int, optional
        The orders of the partial derivatives in `x` and `y` respectively.
    
    Returns
    -------
    vals : ndarray
        The B-spline or its derivative evaluated over the set formed by
        the cross-product of `x` and `y`.
    
    See Also
    --------
    splprep, splrep, splint, sproot, splev
    UnivariateSpline, BivariateSpline
    
    Notes
    -----
        See `bisplrep` to generate the `tck` representation.
    
    References
    ----------
    .. [1] Dierckx P. : An algorithm for surface fitting
       with spline functions
       Ima J. Numer. Anal. 1 (1981) 267-283.
    .. [2] Dierckx P. : An algorithm for surface fitting
       with spline functions
       report tw50, Dept. Computer Science,K.U.Leuven, 1980.
    .. [3] Dierckx P. : Curve and surface fitting with splines,
       Monographs on Numerical Analysis, Oxford University Press, 1993.
",function,"('(x, y, tck, dx=0, dy=0)',)",scipy,1.1.0,scipy.interpolate._fitpack_impl.bisplev,interpolate._fitpack_impl,bisplev,"Python Library Documentation: function bisplev in module scipy.interpolate._fitpack_impl

bisplev(x, y, tck, dx=0, dy=0)
    Evaluate a bivariate B-spline and its derivatives.
    
    Return a rank-2 array of spline function values (or spline derivative
    values) at points given by the cross-product of the rank-1 arrays `x` and
    `y`.  In special cases, return an array or just a float if either `x` or
    `y` or both are floats.  Based on BISPEV from FITPACK.
    
    Parameters
    ----------
    x, y : ndarray
        Rank-1 arrays specifying the domain over which to evaluate the
        spline or its derivative.
    tck : tuple
        A sequence of length 5 returned by `bisplrep` containing the knot
        locations, the coefficients, and the degree of the spline:
        [tx, ty, c, kx, ky].
    dx, dy : int, optional
        The orders of the partial derivatives in `x` and `y` respectively.
    
    Returns
    -------
    vals : ndarray
        The B-spline or its derivative evaluated over the set formed by
        the cross-product of `x` and `y`.
    
    See Also
    --------
    splprep, splrep, splint, sproot, splev
    UnivariateSpline, BivariateSpline
    
    Notes
    -----
        See `bisplrep` to generate the `tck` representation.
    
    References
    ----------
    .. [1] Dierckx P. : An algorithm for surface fitting
       with spline functions
       Ima J. Numer. Anal. 1 (1981) 267-283.
    .. [2] Dierckx P. : An algorithm for surface fitting
       with spline functions
       report tw50, Dept. Computer Science,K.U.Leuven, 1980.
    .. [3] Dierckx P. : Curve and surface fitting with splines,
       Monographs on Numerical Analysis, Oxford University Press, 1993.
",function,"('x', 'y', 'tck', 'dx', 'dy')","(nan, nan, nan, 0, 0)","(nan, nan, nan, 'int', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, y, tck, dx=0, dy=0)',)"
scipy,1.1.0,scipy.interpolate._fitpack_impl.bisplrep,interpolate._fitpack_impl,bisplrep,"Python Library Documentation: function bisplrep in module scipy.interpolate._fitpack_impl

bisplrep(x, y, z, w=None, xb=None, xe=None, yb=None, ye=None, kx=3, ky=3, task=0, s=None, eps=1e-16, tx=None, ty=None, full_output=0, nxest=None, nyest=None, quiet=1)
    Find a bivariate B-spline representation of a surface.
    
    Given a set of data points (x[i], y[i], z[i]) representing a surface
    z=f(x,y), compute a B-spline representation of the surface. Based on
    the routine SURFIT from FITPACK.
    
    Parameters
    ----------
    x, y, z : ndarray
        Rank-1 arrays of data points.
    w : ndarray, optional
        Rank-1 array of weights. By default ``w=np.ones(len(x))``.
    xb, xe : float, optional
        End points of approximation interval in `x`.
        By default ``xb = x.min(), xe=x.max()``.
    yb, ye : float, optional
        End points of approximation interval in `y`.
        By default ``yb=y.min(), ye = y.max()``.
    kx, ky : int, optional
        The degrees of the spline (1 <= kx, ky <= 5).
        Third order (kx=ky=3) is recommended.
    task : int, optional
        If task=0, find knots in x and y and coefficients for a given
        smoothing factor, s.
        If task=1, find knots and coefficients for another value of the
        smoothing factor, s.  bisplrep must have been previously called
        with task=0 or task=1.
        If task=-1, find coefficients for a given set of knots tx, ty.
    s : float, optional
        A non-negative smoothing factor.  If weights correspond
        to the inverse of the standard-deviation of the errors in z,
        then a good s-value should be found in the range
        ``(m-sqrt(2*m),m+sqrt(2*m))`` where m=len(x).
    eps : float, optional
        A threshold for determining the effective rank of an
        over-determined linear system of equations (0 < eps < 1).
        `eps` is not likely to need changing.
    tx, ty : ndarray, optional
        Rank-1 arrays of the knots of the spline for task=-1
    full_output : int, optional
        Non-zero to return optional outputs.
    nxest, nyest : int, optional
        Over-estimates of the total number of knots. If None then
        ``nxest = max(kx+sqrt(m/2),2*kx+3)``,
        ``nyest = max(ky+sqrt(m/2),2*ky+3)``.
    quiet : int, optional
        Non-zero to suppress printing of messages.
        This parameter is deprecated; use standard Python warning filters
        instead.
    
    Returns
    -------
    tck : array_like
        A list [tx, ty, c, kx, ky] containing the knots (tx, ty) and
        coefficients (c) of the bivariate B-spline representation of the
        surface along with the degree of the spline.
    fp : ndarray
        The weighted sum of squared residuals of the spline approximation.
    ier : int
        An integer flag about splrep success.  Success is indicated if
        ier<=0. If ier in [1,2,3] an error occurred but was not raised.
        Otherwise an error is raised.
    msg : str
        A message corresponding to the integer flag, ier.
    
    See Also
    --------
    splprep, splrep, splint, sproot, splev
    UnivariateSpline, BivariateSpline
    
    Notes
    -----
    See `bisplev` to evaluate the value of the B-spline given its tck
    representation.
    
    References
    ----------
    .. [1] Dierckx P.:An algorithm for surface fitting with spline functions
       Ima J. Numer. Anal. 1 (1981) 267-283.
    .. [2] Dierckx P.:An algorithm for surface fitting with spline functions
       report tw50, Dept. Computer Science,K.U.Leuven, 1980.
    .. [3] Dierckx P.:Curve and surface fitting with splines, Monographs on
       Numerical Analysis, Oxford University Press, 1993.
",function,"('(x, y, z, w=None, xb=None, xe=None, yb=None, ye=None, kx=3, ky=3, task=0, s=None, eps=1e-16, tx=None, ty=None, full_output=0, nxest=None, nyest=None, quiet=1)',)",scipy,1.1.0,scipy.interpolate._fitpack_impl.bisplrep,interpolate._fitpack_impl,bisplrep,"Python Library Documentation: function bisplrep in module scipy.interpolate._fitpack_impl

bisplrep(x, y, z, w=None, xb=None, xe=None, yb=None, ye=None, kx=3, ky=3, task=0, s=None, eps=1e-16, tx=None, ty=None, full_output=0, nxest=None, nyest=None, quiet=1)
    Find a bivariate B-spline representation of a surface.
    
    Given a set of data points (x[i], y[i], z[i]) representing a surface
    z=f(x,y), compute a B-spline representation of the surface. Based on
    the routine SURFIT from FITPACK.
    
    Parameters
    ----------
    x, y, z : ndarray
        Rank-1 arrays of data points.
    w : ndarray, optional
        Rank-1 array of weights. By default ``w=np.ones(len(x))``.
    xb, xe : float, optional
        End points of approximation interval in `x`.
        By default ``xb = x.min(), xe=x.max()``.
    yb, ye : float, optional
        End points of approximation interval in `y`.
        By default ``yb=y.min(), ye = y.max()``.
    kx, ky : int, optional
        The degrees of the spline (1 <= kx, ky <= 5).
        Third order (kx=ky=3) is recommended.
    task : int, optional
        If task=0, find knots in x and y and coefficients for a given
        smoothing factor, s.
        If task=1, find knots and coefficients for another value of the
        smoothing factor, s.  bisplrep must have been previously called
        with task=0 or task=1.
        If task=-1, find coefficients for a given set of knots tx, ty.
    s : float, optional
        A non-negative smoothing factor.  If weights correspond
        to the inverse of the standard-deviation of the errors in z,
        then a good s-value should be found in the range
        ``(m-sqrt(2*m),m+sqrt(2*m))`` where m=len(x).
    eps : float, optional
        A threshold for determining the effective rank of an
        over-determined linear system of equations (0 < eps < 1).
        `eps` is not likely to need changing.
    tx, ty : ndarray, optional
        Rank-1 arrays of the knots of the spline for task=-1
    full_output : int, optional
        Non-zero to return optional outputs.
    nxest, nyest : int, optional
        Over-estimates of the total number of knots. If None then
        ``nxest = max(kx+sqrt(m/2),2*kx+3)``,
        ``nyest = max(ky+sqrt(m/2),2*ky+3)``.
    quiet : int, optional
        Non-zero to suppress printing of messages.
        This parameter is deprecated; use standard Python warning filters
        instead.
    
    Returns
    -------
    tck : array_like
        A list [tx, ty, c, kx, ky] containing the knots (tx, ty) and
        coefficients (c) of the bivariate B-spline representation of the
        surface along with the degree of the spline.
    fp : ndarray
        The weighted sum of squared residuals of the spline approximation.
    ier : int
        An integer flag about splrep success.  Success is indicated if
        ier<=0. If ier in [1,2,3] an error occurred but was not raised.
        Otherwise an error is raised.
    msg : str
        A message corresponding to the integer flag, ier.
    
    See Also
    --------
    splprep, splrep, splint, sproot, splev
    UnivariateSpline, BivariateSpline
    
    Notes
    -----
    See `bisplev` to evaluate the value of the B-spline given its tck
    representation.
    
    References
    ----------
    .. [1] Dierckx P.:An algorithm for surface fitting with spline functions
       Ima J. Numer. Anal. 1 (1981) 267-283.
    .. [2] Dierckx P.:An algorithm for surface fitting with spline functions
       report tw50, Dept. Computer Science,K.U.Leuven, 1980.
    .. [3] Dierckx P.:Curve and surface fitting with splines, Monographs on
       Numerical Analysis, Oxford University Press, 1993.
",function,"('x', 'y', 'z', 'w', 'xb', 'xe', 'yb', 'ye', 'kx', 'ky', 'task', 's', 'eps', 'tx', 'ty', 'full_output', 'nxest', 'nyest', 'quiet')","(nan, nan, nan, None, None, None, None, None, 3, 3, 0, None, 1e-16, None, None, 0, None, None, 1)","(nan, nan, nan, 'NoneType', 'NoneType', 'NoneType', 'NoneType', 'NoneType', 'int', 'int', 'int', 'NoneType', 'float', 'NoneType', 'NoneType', 'int', 'NoneType', 'NoneType', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, y, z, w=None, xb=None, xe=None, yb=None, ye=None, kx=3, ky=3, task=0, s=None, eps=1e-16, tx=None, ty=None, full_output=0, nxest=None, nyest=None, quiet=1)',)"
scipy,1.1.0,scipy.interpolate._fitpack_impl.dblint,interpolate._fitpack_impl,dblint,"Python Library Documentation: function dblint in module scipy.interpolate._fitpack_impl

dblint(xa, xb, ya, yb, tck)
    Evaluate the integral of a spline over area [xa,xb] x [ya,yb].
    
    Parameters
    ----------
    xa, xb : float
        The end-points of the x integration interval.
    ya, yb : float
        The end-points of the y integration interval.
    tck : list [tx, ty, c, kx, ky]
        A sequence of length 5 returned by bisplrep containing the knot
        locations tx, ty, the coefficients c, and the degrees kx, ky
        of the spline.
    
    Returns
    -------
    integ : float
        The value of the resulting integral.
",function,"('(xa, xb, ya, yb, tck)',)",scipy,1.1.0,scipy.interpolate._fitpack_impl.dblint,interpolate._fitpack_impl,dblint,"Python Library Documentation: function dblint in module scipy.interpolate._fitpack_impl

dblint(xa, xb, ya, yb, tck)
    Evaluate the integral of a spline over area [xa,xb] x [ya,yb].
    
    Parameters
    ----------
    xa, xb : float
        The end-points of the x integration interval.
    ya, yb : float
        The end-points of the y integration interval.
    tck : list [tx, ty, c, kx, ky]
        A sequence of length 5 returned by bisplrep containing the knot
        locations tx, ty, the coefficients c, and the degrees kx, ky
        of the spline.
    
    Returns
    -------
    integ : float
        The value of the resulting integral.
",function,"('xa', 'xb', 'ya', 'yb', 'tck')","(nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(xa, xb, ya, yb, tck)',)"
scipy,1.1.0,scipy.interpolate._fitpack_impl.iinfo,interpolate._fitpack_impl,iinfo,"Python Library Documentation: class iinfo in module numpy.core.getlimits

class iinfo(builtins.object)
 |  iinfo(type)
 |  
 |  Machine limits for integer types.
 |  
 |  Attributes
 |  ----------
 |  bits : int
 |      The number of bits occupied by the type.
 |  min : int
 |      The smallest integer expressible by the type.
 |  max : int
 |      The largest integer expressible by the type.
 |  
 |  Parameters
 |  ----------
 |  int_type : integer type, dtype, or instance
 |      The kind of integer data type to get information about.
 |  
 |  See Also
 |  --------
 |  finfo : The equivalent for floating point data types.
 |  
 |  Examples
 |  --------
 |  With types:
 |  
 |  >>> ii16 = np.iinfo(np.int16)
 |  >>> ii16.min
 |  -32768
 |  >>> ii16.max
 |  32767
 |  >>> ii32 = np.iinfo(np.int32)
 |  >>> ii32.min
 |  -2147483648
 |  >>> ii32.max
 |  2147483647
 |  
 |  With instances:
 |  
 |  >>> ii32 = np.iinfo(np.int32(10))
 |  >>> ii32.min
 |  -2147483648
 |  >>> ii32.max
 |  2147483647
 |  
 |  Methods defined here:
 |  
 |  __init__(self, int_type)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __str__(self)
 |      String representation.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  max
 |      Maximum value of given dtype.
 |  
 |  min
 |      Minimum value of given dtype.
",class,"('(self, int_type)',)",scipy,1.1.0,scipy.interpolate._fitpack_impl.iinfo,interpolate._fitpack_impl,iinfo,"Python Library Documentation: class iinfo in module numpy.core.getlimits

class iinfo(builtins.object)
 |  iinfo(type)
 |  
 |  Machine limits for integer types.
 |  
 |  Attributes
 |  ----------
 |  bits : int
 |      The number of bits occupied by the type.
 |  min : int
 |      The smallest integer expressible by the type.
 |  max : int
 |      The largest integer expressible by the type.
 |  
 |  Parameters
 |  ----------
 |  int_type : integer type, dtype, or instance
 |      The kind of integer data type to get information about.
 |  
 |  See Also
 |  --------
 |  finfo : The equivalent for floating point data types.
 |  
 |  Examples
 |  --------
 |  With types:
 |  
 |  >>> ii16 = np.iinfo(np.int16)
 |  >>> ii16.min
 |  -32768
 |  >>> ii16.max
 |  32767
 |  >>> ii32 = np.iinfo(np.int32)
 |  >>> ii32.min
 |  -2147483648
 |  >>> ii32.max
 |  2147483647
 |  
 |  With instances:
 |  
 |  >>> ii32 = np.iinfo(np.int32(10))
 |  >>> ii32.min
 |  -2147483648
 |  >>> ii32.max
 |  2147483647
 |  
 |  Methods defined here:
 |  
 |  __init__(self, int_type)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __str__(self)
 |      String representation.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  max
 |      Maximum value of given dtype.
 |  
 |  min
 |      Minimum value of given dtype.
",class,"('self', 'int_type')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(self, int_type)',)"
scipy,1.1.0,scipy.interpolate._fitpack_impl.insert,interpolate._fitpack_impl,insert,"Python Library Documentation: function insert in module scipy.interpolate._fitpack_impl

insert(x, tck, m=1, per=0)
    Insert knots into a B-spline.
    
    Given the knots and coefficients of a B-spline representation, create a
    new B-spline with a knot inserted `m` times at point `x`.
    This is a wrapper around the FORTRAN routine insert of FITPACK.
    
    Parameters
    ----------
    x (u) : array_like
        A 1-D point at which to insert a new knot(s).  If `tck` was returned
        from ``splprep``, then the parameter values, u should be given.
    tck : tuple
        A tuple (t,c,k) returned by ``splrep`` or ``splprep`` containing
        the vector of knots, the B-spline coefficients,
        and the degree of the spline.
    m : int, optional
        The number of times to insert the given knot (its multiplicity).
        Default is 1.
    per : int, optional
        If non-zero, the input spline is considered periodic.
    
    Returns
    -------
    tck : tuple
        A tuple (t,c,k) containing the vector of knots, the B-spline
        coefficients, and the degree of the new spline.
        ``t(k+1) <= x <= t(n-k)``, where k is the degree of the spline.
        In case of a periodic spline (``per != 0``) there must be
        either at least k interior knots t(j) satisfying ``t(k+1)<t(j)<=x``
        or at least k interior knots t(j) satisfying ``x<=t(j)<t(n-k)``.
    
    Notes
    -----
    Based on algorithms from [1]_ and [2]_.
    
    References
    ----------
    .. [1] W. Boehm, ""Inserting new knots into b-spline curves."",
        Computer Aided Design, 12, p.199-201, 1980.
    .. [2] P. Dierckx, ""Curve and surface fitting with splines, Monographs on
        Numerical Analysis"", Oxford University Press, 1993.
",function,"('(x, tck, m=1, per=0)',)",scipy,1.1.0,scipy.interpolate._fitpack_impl.insert,interpolate._fitpack_impl,insert,"Python Library Documentation: function insert in module scipy.interpolate._fitpack_impl

insert(x, tck, m=1, per=0)
    Insert knots into a B-spline.
    
    Given the knots and coefficients of a B-spline representation, create a
    new B-spline with a knot inserted `m` times at point `x`.
    This is a wrapper around the FORTRAN routine insert of FITPACK.
    
    Parameters
    ----------
    x (u) : array_like
        A 1-D point at which to insert a new knot(s).  If `tck` was returned
        from ``splprep``, then the parameter values, u should be given.
    tck : tuple
        A tuple (t,c,k) returned by ``splrep`` or ``splprep`` containing
        the vector of knots, the B-spline coefficients,
        and the degree of the spline.
    m : int, optional
        The number of times to insert the given knot (its multiplicity).
        Default is 1.
    per : int, optional
        If non-zero, the input spline is considered periodic.
    
    Returns
    -------
    tck : tuple
        A tuple (t,c,k) containing the vector of knots, the B-spline
        coefficients, and the degree of the new spline.
        ``t(k+1) <= x <= t(n-k)``, where k is the degree of the spline.
        In case of a periodic spline (``per != 0``) there must be
        either at least k interior knots t(j) satisfying ``t(k+1)<t(j)<=x``
        or at least k interior knots t(j) satisfying ``x<=t(j)<t(n-k)``.
    
    Notes
    -----
    Based on algorithms from [1]_ and [2]_.
    
    References
    ----------
    .. [1] W. Boehm, ""Inserting new knots into b-spline curves."",
        Computer Aided Design, 12, p.199-201, 1980.
    .. [2] P. Dierckx, ""Curve and surface fitting with splines, Monographs on
        Numerical Analysis"", Oxford University Press, 1993.
",function,"('x', 'tck', 'm', 'per')","(nan, nan, 1, 0)","(nan, nan, 'int', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, tck, m=1, per=0)',)"
scipy,1.1.0,scipy.interpolate._fitpack_impl.intc,interpolate._fitpack_impl,int32,"Python Library Documentation: class int32 in module numpy

class int32(signedinteger)
 |  Base class for numpy scalar types.
 |  
 |  Class from which most (all?) numpy scalar types are derived.  For
 |  consistency, exposes the same API as `ndarray`, despite many
 |  consequent attributes being either ""get-only,"" or completely irrelevant.
 |  This is the class from which it is strongly suggested users should derive
 |  custom scalar types.
 |  
 |  Method resolution order:
 |      int32
 |      signedinteger
 |      integer
 |      number
 |      generic
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from integer:
 |  
 |  denominator
 |      denominator of value (1)
 |  
 |  numerator
 |      numerator of value (the value itself)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from generic:
 |  
 |  __array__(...)
 |      sc.__array__(|type) return 0-dim array
 |  
 |  __array_wrap__(...)
 |      sc.__array_wrap__(obj) return scalar from array
 |  
 |  __copy__(...)
 |  
 |  __deepcopy__(...)
 |  
 |  __format__(...)
 |      NumPy array scalar formatter
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __round__(...)
 |  
 |  __setstate__(...)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  all(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  any(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmax(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmin(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argsort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  astype(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  byteswap(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  choose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  clip(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  compress(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  conj(...)
 |  
 |  conjugate(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  copy(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumprod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumsum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  diagonal(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dump(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dumps(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  fill(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  flatten(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  getfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  item(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  itemset(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  max(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  mean(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  min(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  newbyteorder(...)
 |      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.
 |      
 |      The `new_order` code can be any from the following:
 |      
 |      * 'S' - swap dtype from current to opposite endian
 |      * {'<', 'L'} - little endian
 |      * {'>', 'B'} - big endian
 |      * {'=', 'N'} - native order
 |      * {'|', 'I'} - ignore (no change to byte order)
 |      
 |      Parameters
 |      ----------
 |      new_order : str, optional
 |          Byte order to force; a value from the byte order specifications
 |          above.  The default value ('S') results in swapping the current
 |          byte order. The code does a case-insensitive check on the first
 |          letter of `new_order` for the alternatives above.  For example,
 |          any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 |      
 |      
 |      Returns
 |      -------
 |      new_dtype : dtype
 |          New `dtype` object with the given change to the byte order.
 |  
 |  nonzero(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  prod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ptp(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  put(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ravel(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  repeat(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  reshape(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  resize(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  round(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  searchsorted(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setflags(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  squeeze(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  std(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  swapaxes(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  take(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tobytes(...)
 |  
 |  tofile(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tolist(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tostring(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  trace(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  transpose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  var(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  view(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from generic:
 |  
 |  T
 |      transpose
 |  
 |  __array_interface__
 |      Array protocol: Python side
 |  
 |  __array_priority__
 |      Array priority.
 |  
 |  __array_struct__
 |      Array protocol: struct
 |  
 |  base
 |      base object
 |  
 |  data
 |      pointer to start of data
 |  
 |  dtype
 |      get array data-descriptor
 |  
 |  flags
 |      integer value of flags
 |  
 |  flat
 |      a 1-d view of scalar
 |  
 |  imag
 |      imaginary part of scalar
 |  
 |  itemsize
 |      length of one element in bytes
 |  
 |  nbytes
 |      length of item in bytes
 |  
 |  ndim
 |      number of array dimensions
 |  
 |  real
 |      real part of scalar
 |  
 |  shape
 |      tuple of array dimensions
 |  
 |  size
 |      number of elements in the gentype
 |  
 |  strides
 |      tuple of bytes steps in each dimension
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.interpolate._fitpack_impl.intc,interpolate._fitpack_impl,int32,"Python Library Documentation: class int32 in module numpy

class int32(signedinteger)
 |  Base class for numpy scalar types.
 |  
 |  Class from which most (all?) numpy scalar types are derived.  For
 |  consistency, exposes the same API as `ndarray`, despite many
 |  consequent attributes being either ""get-only,"" or completely irrelevant.
 |  This is the class from which it is strongly suggested users should derive
 |  custom scalar types.
 |  
 |  Method resolution order:
 |      int32
 |      signedinteger
 |      integer
 |      number
 |      generic
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from integer:
 |  
 |  denominator
 |      denominator of value (1)
 |  
 |  numerator
 |      numerator of value (the value itself)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from generic:
 |  
 |  __array__(...)
 |      sc.__array__(|type) return 0-dim array
 |  
 |  __array_wrap__(...)
 |      sc.__array_wrap__(obj) return scalar from array
 |  
 |  __copy__(...)
 |  
 |  __deepcopy__(...)
 |  
 |  __format__(...)
 |      NumPy array scalar formatter
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __round__(...)
 |  
 |  __setstate__(...)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  all(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  any(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmax(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmin(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argsort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  astype(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  byteswap(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  choose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  clip(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  compress(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  conj(...)
 |  
 |  conjugate(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  copy(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumprod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumsum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  diagonal(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dump(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dumps(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  fill(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  flatten(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  getfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  item(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  itemset(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  max(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  mean(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  min(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  newbyteorder(...)
 |      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.
 |      
 |      The `new_order` code can be any from the following:
 |      
 |      * 'S' - swap dtype from current to opposite endian
 |      * {'<', 'L'} - little endian
 |      * {'>', 'B'} - big endian
 |      * {'=', 'N'} - native order
 |      * {'|', 'I'} - ignore (no change to byte order)
 |      
 |      Parameters
 |      ----------
 |      new_order : str, optional
 |          Byte order to force; a value from the byte order specifications
 |          above.  The default value ('S') results in swapping the current
 |          byte order. The code does a case-insensitive check on the first
 |          letter of `new_order` for the alternatives above.  For example,
 |          any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 |      
 |      
 |      Returns
 |      -------
 |      new_dtype : dtype
 |          New `dtype` object with the given change to the byte order.
 |  
 |  nonzero(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  prod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ptp(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  put(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ravel(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  repeat(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  reshape(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  resize(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  round(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  searchsorted(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setflags(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  squeeze(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  std(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  swapaxes(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  take(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tobytes(...)
 |  
 |  tofile(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tolist(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tostring(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  trace(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  transpose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  var(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  view(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from generic:
 |  
 |  T
 |      transpose
 |  
 |  __array_interface__
 |      Array protocol: Python side
 |  
 |  __array_priority__
 |      Array priority.
 |  
 |  __array_struct__
 |      Array protocol: struct
 |  
 |  base
 |      base object
 |  
 |  data
 |      pointer to start of data
 |  
 |  dtype
 |      get array data-descriptor
 |  
 |  flags
 |      integer value of flags
 |  
 |  flat
 |      a 1-d view of scalar
 |  
 |  imag
 |      imaginary part of scalar
 |  
 |  itemsize
 |      length of one element in bytes
 |  
 |  nbytes
 |      length of item in bytes
 |  
 |  ndim
 |      number of array dimensions
 |  
 |  real
 |      real part of scalar
 |  
 |  shape
 |      tuple of array dimensions
 |  
 |  size
 |      number of elements in the gentype
 |  
 |  strides
 |      tuple of bytes steps in each dimension
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.interpolate._fitpack_impl.ones,interpolate._fitpack_impl,ones,"Python Library Documentation: function ones in module numpy.core.numeric

ones(shape, dtype=None, order='C')
    Return a new array of given shape and type, filled with ones.
    
    Parameters
    ----------
    shape : int or sequence of ints
        Shape of the new array, e.g., ``(2, 3)`` or ``2``.
    dtype : data-type, optional
        The desired data-type for the array, e.g., `numpy.int8`.  Default is
        `numpy.float64`.
    order : {'C', 'F'}, optional
        Whether to store multidimensional data in C- or Fortran-contiguous
        (row- or column-wise) order in memory.
    
    Returns
    -------
    out : ndarray
        Array of ones with the given shape, dtype, and order.
    
    See Also
    --------
    zeros, ones_like
    
    Examples
    --------
    >>> np.ones(5)
    array([ 1.,  1.,  1.,  1.,  1.])
    
    >>> np.ones((5,), dtype=int)
    array([1, 1, 1, 1, 1])
    
    >>> np.ones((2, 1))
    array([[ 1.],
           [ 1.]])
    
    >>> s = (2,2)
    >>> np.ones(s)
    array([[ 1.,  1.],
           [ 1.,  1.]])
",function,"(""(shape, dtype=None, order='C')"",)",scipy,1.1.0,scipy.interpolate._fitpack_impl.ones,interpolate._fitpack_impl,ones,"Python Library Documentation: function ones in module numpy.core.numeric

ones(shape, dtype=None, order='C')
    Return a new array of given shape and type, filled with ones.
    
    Parameters
    ----------
    shape : int or sequence of ints
        Shape of the new array, e.g., ``(2, 3)`` or ``2``.
    dtype : data-type, optional
        The desired data-type for the array, e.g., `numpy.int8`.  Default is
        `numpy.float64`.
    order : {'C', 'F'}, optional
        Whether to store multidimensional data in C- or Fortran-contiguous
        (row- or column-wise) order in memory.
    
    Returns
    -------
    out : ndarray
        Array of ones with the given shape, dtype, and order.
    
    See Also
    --------
    zeros, ones_like
    
    Examples
    --------
    >>> np.ones(5)
    array([ 1.,  1.,  1.,  1.,  1.])
    
    >>> np.ones((5,), dtype=int)
    array([1, 1, 1, 1, 1])
    
    >>> np.ones((2, 1))
    array([[ 1.],
           [ 1.]])
    
    >>> s = (2,2)
    >>> np.ones(s)
    array([[ 1.,  1.],
           [ 1.,  1.]])
",function,"('shape', 'dtype', 'order')","(nan, None, 'C')","(nan, 'NoneType', 'str')","('arg_info', 'arg_info', 'arg_info')","(""(shape, dtype=None, order='C')"",)"
scipy,1.1.0,scipy.interpolate._fitpack_impl.ravel,interpolate._fitpack_impl,ravel,"Python Library Documentation: function ravel in module numpy.core.fromnumeric

ravel(a, order='C')
    Return a contiguous flattened array.
    
    A 1-D array, containing the elements of the input, is returned.  A copy is
    made only if needed.
    
    As of NumPy 1.10, the returned array will have the same type as the input
    array. (for example, a masked array will be returned for a masked array
    input)
    
    Parameters
    ----------
    a : array_like
        Input array.  The elements in `a` are read in the order specified by
        `order`, and packed as a 1-D array.
    order : {'C','F', 'A', 'K'}, optional
    
        The elements of `a` are read using this index order. 'C' means
        to index the elements in row-major, C-style order,
        with the last axis index changing fastest, back to the first
        axis index changing slowest.  'F' means to index the elements
        in column-major, Fortran-style order, with the
        first index changing fastest, and the last index changing
        slowest. Note that the 'C' and 'F' options take no account of
        the memory layout of the underlying array, and only refer to
        the order of axis indexing.  'A' means to read the elements in
        Fortran-like index order if `a` is Fortran *contiguous* in
        memory, C-like order otherwise.  'K' means to read the
        elements in the order they occur in memory, except for
        reversing the data when strides are negative.  By default, 'C'
        index order is used.
    
    Returns
    -------
    y : array_like
        If `a` is a matrix, y is a 1-D ndarray, otherwise y is an array of
        the same subtype as `a`. The shape of the returned array is
        ``(a.size,)``. Matrices are special cased for backward
        compatibility.
    
    See Also
    --------
    ndarray.flat : 1-D iterator over an array.
    ndarray.flatten : 1-D array copy of the elements of an array
                      in row-major order.
    ndarray.reshape : Change the shape of an array without changing its data.
    
    Notes
    -----
    In row-major, C-style order, in two dimensions, the row index
    varies the slowest, and the column index the quickest.  This can
    be generalized to multiple dimensions, where row-major order
    implies that the index along the first axis varies slowest, and
    the index along the last quickest.  The opposite holds for
    column-major, Fortran-style index ordering.
    
    When a view is desired in as many cases as possible, ``arr.reshape(-1)``
    may be preferable.
    
    Examples
    --------
    It is equivalent to ``reshape(-1, order=order)``.
    
    >>> x = np.array([[1, 2, 3], [4, 5, 6]])
    >>> print(np.ravel(x))
    [1 2 3 4 5 6]
    
    >>> print(x.reshape(-1))
    [1 2 3 4 5 6]
    
    >>> print(np.ravel(x, order='F'))
    [1 4 2 5 3 6]
    
    When ``order`` is 'A', it will preserve the array's 'C' or 'F' ordering:
    
    >>> print(np.ravel(x.T))
    [1 4 2 5 3 6]
    >>> print(np.ravel(x.T, order='A'))
    [1 2 3 4 5 6]
    
    When ``order`` is 'K', it will preserve orderings that are neither 'C'
    nor 'F', but won't reverse axes:
    
    >>> a = np.arange(3)[::-1]; a
    array([2, 1, 0])
    >>> a.ravel(order='C')
    array([2, 1, 0])
    >>> a.ravel(order='K')
    array([2, 1, 0])
    
    >>> a = np.arange(12).reshape(2,3,2).swapaxes(1,2); a
    array([[[ 0,  2,  4],
            [ 1,  3,  5]],
           [[ 6,  8, 10],
            [ 7,  9, 11]]])
    >>> a.ravel(order='C')
    array([ 0,  2,  4,  1,  3,  5,  6,  8, 10,  7,  9, 11])
    >>> a.ravel(order='K')
    array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
",function,"(""(a, order='C')"",)",scipy,1.1.0,scipy.interpolate._fitpack_impl.ravel,interpolate._fitpack_impl,ravel,"Python Library Documentation: function ravel in module numpy.core.fromnumeric

ravel(a, order='C')
    Return a contiguous flattened array.
    
    A 1-D array, containing the elements of the input, is returned.  A copy is
    made only if needed.
    
    As of NumPy 1.10, the returned array will have the same type as the input
    array. (for example, a masked array will be returned for a masked array
    input)
    
    Parameters
    ----------
    a : array_like
        Input array.  The elements in `a` are read in the order specified by
        `order`, and packed as a 1-D array.
    order : {'C','F', 'A', 'K'}, optional
    
        The elements of `a` are read using this index order. 'C' means
        to index the elements in row-major, C-style order,
        with the last axis index changing fastest, back to the first
        axis index changing slowest.  'F' means to index the elements
        in column-major, Fortran-style order, with the
        first index changing fastest, and the last index changing
        slowest. Note that the 'C' and 'F' options take no account of
        the memory layout of the underlying array, and only refer to
        the order of axis indexing.  'A' means to read the elements in
        Fortran-like index order if `a` is Fortran *contiguous* in
        memory, C-like order otherwise.  'K' means to read the
        elements in the order they occur in memory, except for
        reversing the data when strides are negative.  By default, 'C'
        index order is used.
    
    Returns
    -------
    y : array_like
        If `a` is a matrix, y is a 1-D ndarray, otherwise y is an array of
        the same subtype as `a`. The shape of the returned array is
        ``(a.size,)``. Matrices are special cased for backward
        compatibility.
    
    See Also
    --------
    ndarray.flat : 1-D iterator over an array.
    ndarray.flatten : 1-D array copy of the elements of an array
                      in row-major order.
    ndarray.reshape : Change the shape of an array without changing its data.
    
    Notes
    -----
    In row-major, C-style order, in two dimensions, the row index
    varies the slowest, and the column index the quickest.  This can
    be generalized to multiple dimensions, where row-major order
    implies that the index along the first axis varies slowest, and
    the index along the last quickest.  The opposite holds for
    column-major, Fortran-style index ordering.
    
    When a view is desired in as many cases as possible, ``arr.reshape(-1)``
    may be preferable.
    
    Examples
    --------
    It is equivalent to ``reshape(-1, order=order)``.
    
    >>> x = np.array([[1, 2, 3], [4, 5, 6]])
    >>> print(np.ravel(x))
    [1 2 3 4 5 6]
    
    >>> print(x.reshape(-1))
    [1 2 3 4 5 6]
    
    >>> print(np.ravel(x, order='F'))
    [1 4 2 5 3 6]
    
    When ``order`` is 'A', it will preserve the array's 'C' or 'F' ordering:
    
    >>> print(np.ravel(x.T))
    [1 4 2 5 3 6]
    >>> print(np.ravel(x.T, order='A'))
    [1 2 3 4 5 6]
    
    When ``order`` is 'K', it will preserve orderings that are neither 'C'
    nor 'F', but won't reverse axes:
    
    >>> a = np.arange(3)[::-1]; a
    array([2, 1, 0])
    >>> a.ravel(order='C')
    array([2, 1, 0])
    >>> a.ravel(order='K')
    array([2, 1, 0])
    
    >>> a = np.arange(12).reshape(2,3,2).swapaxes(1,2); a
    array([[[ 0,  2,  4],
            [ 1,  3,  5]],
           [[ 6,  8, 10],
            [ 7,  9, 11]]])
    >>> a.ravel(order='C')
    array([ 0,  2,  4,  1,  3,  5,  6,  8, 10,  7,  9, 11])
    >>> a.ravel(order='K')
    array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
",function,"('a', 'order')","(nan, 'C')","(nan, 'str')","('arg_info', 'arg_info')","(""(a, order='C')"",)"
scipy,1.1.0,scipy.interpolate._fitpack_impl.spalde,interpolate._fitpack_impl,spalde,"Python Library Documentation: function spalde in module scipy.interpolate._fitpack_impl

spalde(x, tck)
    Evaluate all derivatives of a B-spline.
    
    Given the knots and coefficients of a cubic B-spline compute all
    derivatives up to order k at a point (or set of points).
    
    Parameters
    ----------
    x : array_like
        A point or a set of points at which to evaluate the derivatives.
        Note that ``t(k) <= x <= t(n-k+1)`` must hold for each `x`.
    tck : tuple
        A tuple (t,c,k) containing the vector of knots,
        the B-spline coefficients, and the degree of the spline.
    
    Returns
    -------
    results : {ndarray, list of ndarrays}
        An array (or a list of arrays) containing all derivatives
        up to order k inclusive for each point `x`.
    
    See Also
    --------
    splprep, splrep, splint, sproot, splev, bisplrep, bisplev,
    UnivariateSpline, BivariateSpline
    
    References
    ----------
    .. [1] de Boor C : On calculating with b-splines, J. Approximation Theory
       6 (1972) 50-62.
    .. [2] Cox M.G. : The numerical evaluation of b-splines, J. Inst. Maths
       applics 10 (1972) 134-149.
    .. [3] Dierckx P. : Curve and surface fitting with splines, Monographs on
       Numerical Analysis, Oxford University Press, 1993.
",function,"('(x, tck)',)",scipy,1.1.0,scipy.interpolate._fitpack_impl.spalde,interpolate._fitpack_impl,spalde,"Python Library Documentation: function spalde in module scipy.interpolate._fitpack_impl

spalde(x, tck)
    Evaluate all derivatives of a B-spline.
    
    Given the knots and coefficients of a cubic B-spline compute all
    derivatives up to order k at a point (or set of points).
    
    Parameters
    ----------
    x : array_like
        A point or a set of points at which to evaluate the derivatives.
        Note that ``t(k) <= x <= t(n-k+1)`` must hold for each `x`.
    tck : tuple
        A tuple (t,c,k) containing the vector of knots,
        the B-spline coefficients, and the degree of the spline.
    
    Returns
    -------
    results : {ndarray, list of ndarrays}
        An array (or a list of arrays) containing all derivatives
        up to order k inclusive for each point `x`.
    
    See Also
    --------
    splprep, splrep, splint, sproot, splev, bisplrep, bisplev,
    UnivariateSpline, BivariateSpline
    
    References
    ----------
    .. [1] de Boor C : On calculating with b-splines, J. Approximation Theory
       6 (1972) 50-62.
    .. [2] Cox M.G. : The numerical evaluation of b-splines, J. Inst. Maths
       applics 10 (1972) 134-149.
    .. [3] Dierckx P. : Curve and surface fitting with splines, Monographs on
       Numerical Analysis, Oxford University Press, 1993.
",function,"('x', 'tck')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(x, tck)',)"
scipy,1.1.0,scipy.interpolate._fitpack_impl.splantider,interpolate._fitpack_impl,splantider,"Python Library Documentation: function splantider in module scipy.interpolate._fitpack_impl

splantider(tck, n=1)
    Compute the spline for the antiderivative (integral) of a given spline.
    
    Parameters
    ----------
    tck : tuple of (t, c, k)
        Spline whose antiderivative to compute
    n : int, optional
        Order of antiderivative to evaluate. Default: 1
    
    Returns
    -------
    tck_ader : tuple of (t2, c2, k2)
        Spline of order k2=k+n representing the antiderivative of the input
        spline.
    
    See Also
    --------
    splder, splev, spalde
    
    Notes
    -----
    The `splder` function is the inverse operation of this function.
    Namely, ``splder(splantider(tck))`` is identical to `tck`, modulo
    rounding error.
    
    .. versionadded:: 0.13.0
    
    Examples
    --------
    >>> from scipy.interpolate import splrep, splder, splantider, splev
    >>> x = np.linspace(0, np.pi/2, 70)
    >>> y = 1 / np.sqrt(1 - 0.8*np.sin(x)**2)
    >>> spl = splrep(x, y)
    
    The derivative is the inverse operation of the antiderivative,
    although some floating point error accumulates:
    
    >>> splev(1.7, spl), splev(1.7, splder(splantider(spl)))
    (array(2.1565429877197317), array(2.1565429877201865))
    
    Antiderivative can be used to evaluate definite integrals:
    
    >>> ispl = splantider(spl)
    >>> splev(np.pi/2, ispl) - splev(0, ispl)
    2.2572053588768486
    
    This is indeed an approximation to the complete elliptic integral
    :math:`K(m) = \int_0^{\pi/2} [1 - m\sin^2 x]^{-1/2} dx`:
    
    >>> from scipy.special import ellipk
    >>> ellipk(0.8)
    2.2572053268208538
",function,"('(tck, n=1)',)",scipy,1.1.0,scipy.interpolate._fitpack_impl.splantider,interpolate._fitpack_impl,splantider,"Python Library Documentation: function splantider in module scipy.interpolate._fitpack_impl

splantider(tck, n=1)
    Compute the spline for the antiderivative (integral) of a given spline.
    
    Parameters
    ----------
    tck : tuple of (t, c, k)
        Spline whose antiderivative to compute
    n : int, optional
        Order of antiderivative to evaluate. Default: 1
    
    Returns
    -------
    tck_ader : tuple of (t2, c2, k2)
        Spline of order k2=k+n representing the antiderivative of the input
        spline.
    
    See Also
    --------
    splder, splev, spalde
    
    Notes
    -----
    The `splder` function is the inverse operation of this function.
    Namely, ``splder(splantider(tck))`` is identical to `tck`, modulo
    rounding error.
    
    .. versionadded:: 0.13.0
    
    Examples
    --------
    >>> from scipy.interpolate import splrep, splder, splantider, splev
    >>> x = np.linspace(0, np.pi/2, 70)
    >>> y = 1 / np.sqrt(1 - 0.8*np.sin(x)**2)
    >>> spl = splrep(x, y)
    
    The derivative is the inverse operation of the antiderivative,
    although some floating point error accumulates:
    
    >>> splev(1.7, spl), splev(1.7, splder(splantider(spl)))
    (array(2.1565429877197317), array(2.1565429877201865))
    
    Antiderivative can be used to evaluate definite integrals:
    
    >>> ispl = splantider(spl)
    >>> splev(np.pi/2, ispl) - splev(0, ispl)
    2.2572053588768486
    
    This is indeed an approximation to the complete elliptic integral
    :math:`K(m) = \int_0^{\pi/2} [1 - m\sin^2 x]^{-1/2} dx`:
    
    >>> from scipy.special import ellipk
    >>> ellipk(0.8)
    2.2572053268208538
",function,"('tck', 'n')","(nan, 1)","(nan, 'int')","('arg_info', 'arg_info')","('(tck, n=1)',)"
scipy,1.1.0,scipy.interpolate._fitpack_impl.splder,interpolate._fitpack_impl,splder,"Python Library Documentation: function splder in module scipy.interpolate._fitpack_impl

splder(tck, n=1)
    Compute the spline representation of the derivative of a given spline
    
    Parameters
    ----------
    tck : tuple of (t, c, k)
        Spline whose derivative to compute
    n : int, optional
        Order of derivative to evaluate. Default: 1
    
    Returns
    -------
    tck_der : tuple of (t2, c2, k2)
        Spline of order k2=k-n representing the derivative
        of the input spline.
    
    Notes
    -----
    
    .. versionadded:: 0.13.0
    
    See Also
    --------
    splantider, splev, spalde
    
    Examples
    --------
    This can be used for finding maxima of a curve:
    
    >>> from scipy.interpolate import splrep, splder, sproot
    >>> x = np.linspace(0, 10, 70)
    >>> y = np.sin(x)
    >>> spl = splrep(x, y, k=4)
    
    Now, differentiate the spline and find the zeros of the
    derivative. (NB: `sproot` only works for order 3 splines, so we
    fit an order 4 spline):
    
    >>> dspl = splder(spl)
    >>> sproot(dspl) / np.pi
    array([ 0.50000001,  1.5       ,  2.49999998])
    
    This agrees well with roots :math:`\pi/2 + n\pi` of
    :math:`\cos(x) = \sin'(x)`.
",function,"('(tck, n=1)',)",scipy,1.1.0,scipy.interpolate._fitpack_impl.splder,interpolate._fitpack_impl,splder,"Python Library Documentation: function splder in module scipy.interpolate._fitpack_impl

splder(tck, n=1)
    Compute the spline representation of the derivative of a given spline
    
    Parameters
    ----------
    tck : tuple of (t, c, k)
        Spline whose derivative to compute
    n : int, optional
        Order of derivative to evaluate. Default: 1
    
    Returns
    -------
    tck_der : tuple of (t2, c2, k2)
        Spline of order k2=k-n representing the derivative
        of the input spline.
    
    Notes
    -----
    
    .. versionadded:: 0.13.0
    
    See Also
    --------
    splantider, splev, spalde
    
    Examples
    --------
    This can be used for finding maxima of a curve:
    
    >>> from scipy.interpolate import splrep, splder, sproot
    >>> x = np.linspace(0, 10, 70)
    >>> y = np.sin(x)
    >>> spl = splrep(x, y, k=4)
    
    Now, differentiate the spline and find the zeros of the
    derivative. (NB: `sproot` only works for order 3 splines, so we
    fit an order 4 spline):
    
    >>> dspl = splder(spl)
    >>> sproot(dspl) / np.pi
    array([ 0.50000001,  1.5       ,  2.49999998])
    
    This agrees well with roots :math:`\pi/2 + n\pi` of
    :math:`\cos(x) = \sin'(x)`.
",function,"('tck', 'n')","(nan, 1)","(nan, 'int')","('arg_info', 'arg_info')","('(tck, n=1)',)"
scipy,1.1.0,scipy.interpolate._fitpack_impl.splev,interpolate._fitpack_impl,splev,"Python Library Documentation: function splev in module scipy.interpolate._fitpack_impl

splev(x, tck, der=0, ext=0)
    Evaluate a B-spline or its derivatives.
    
    Given the knots and coefficients of a B-spline representation, evaluate
    the value of the smoothing polynomial and its derivatives.  This is a
    wrapper around the FORTRAN routines splev and splder of FITPACK.
    
    Parameters
    ----------
    x : array_like
        An array of points at which to return the value of the smoothed
        spline or its derivatives.  If `tck` was returned from `splprep`,
        then the parameter values, u should be given.
    tck : tuple
        A sequence of length 3 returned by `splrep` or `splprep` containing
        the knots, coefficients, and degree of the spline.
    der : int, optional
        The order of derivative of the spline to compute (must be less than
        or equal to k).
    ext : int, optional
        Controls the value returned for elements of ``x`` not in the
        interval defined by the knot sequence.
    
        * if ext=0, return the extrapolated value.
        * if ext=1, return 0
        * if ext=2, raise a ValueError
        * if ext=3, return the boundary value.
    
        The default value is 0.
    
    Returns
    -------
    y : ndarray or list of ndarrays
        An array of values representing the spline function evaluated at
        the points in ``x``.  If `tck` was returned from `splprep`, then this
        is a list of arrays representing the curve in N-dimensional space.
    
    See Also
    --------
    splprep, splrep, sproot, spalde, splint
    bisplrep, bisplev
    
    References
    ----------
    .. [1] C. de Boor, ""On calculating with b-splines"", J. Approximation
        Theory, 6, p.50-62, 1972.
    .. [2] M.G. Cox, ""The numerical evaluation of b-splines"", J. Inst. Maths
        Applics, 10, p.134-149, 1972.
    .. [3] P. Dierckx, ""Curve and surface fitting with splines"", Monographs
        on Numerical Analysis, Oxford University Press, 1993.
",function,"('(x, tck, der=0, ext=0)',)",scipy,1.1.0,scipy.interpolate._fitpack_impl.splev,interpolate._fitpack_impl,splev,"Python Library Documentation: function splev in module scipy.interpolate._fitpack_impl

splev(x, tck, der=0, ext=0)
    Evaluate a B-spline or its derivatives.
    
    Given the knots and coefficients of a B-spline representation, evaluate
    the value of the smoothing polynomial and its derivatives.  This is a
    wrapper around the FORTRAN routines splev and splder of FITPACK.
    
    Parameters
    ----------
    x : array_like
        An array of points at which to return the value of the smoothed
        spline or its derivatives.  If `tck` was returned from `splprep`,
        then the parameter values, u should be given.
    tck : tuple
        A sequence of length 3 returned by `splrep` or `splprep` containing
        the knots, coefficients, and degree of the spline.
    der : int, optional
        The order of derivative of the spline to compute (must be less than
        or equal to k).
    ext : int, optional
        Controls the value returned for elements of ``x`` not in the
        interval defined by the knot sequence.
    
        * if ext=0, return the extrapolated value.
        * if ext=1, return 0
        * if ext=2, raise a ValueError
        * if ext=3, return the boundary value.
    
        The default value is 0.
    
    Returns
    -------
    y : ndarray or list of ndarrays
        An array of values representing the spline function evaluated at
        the points in ``x``.  If `tck` was returned from `splprep`, then this
        is a list of arrays representing the curve in N-dimensional space.
    
    See Also
    --------
    splprep, splrep, sproot, spalde, splint
    bisplrep, bisplev
    
    References
    ----------
    .. [1] C. de Boor, ""On calculating with b-splines"", J. Approximation
        Theory, 6, p.50-62, 1972.
    .. [2] M.G. Cox, ""The numerical evaluation of b-splines"", J. Inst. Maths
        Applics, 10, p.134-149, 1972.
    .. [3] P. Dierckx, ""Curve and surface fitting with splines"", Monographs
        on Numerical Analysis, Oxford University Press, 1993.
",function,"('x', 'tck', 'der', 'ext')","(nan, nan, 0, 0)","(nan, nan, 'int', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, tck, der=0, ext=0)',)"
scipy,1.1.0,scipy.interpolate._fitpack_impl.splint,interpolate._fitpack_impl,splint,"Python Library Documentation: function splint in module scipy.interpolate._fitpack_impl

splint(a, b, tck, full_output=0)
    Evaluate the definite integral of a B-spline.
    
    Given the knots and coefficients of a B-spline, evaluate the definite
    integral of the smoothing polynomial between two given points.
    
    Parameters
    ----------
    a, b : float
        The end-points of the integration interval.
    tck : tuple
        A tuple (t,c,k) containing the vector of knots, the B-spline
        coefficients, and the degree of the spline (see `splev`).
    full_output : int, optional
        Non-zero to return optional output.
    
    Returns
    -------
    integral : float
        The resulting integral.
    wrk : ndarray
        An array containing the integrals of the normalized B-splines
        defined on the set of knots.
    
    Notes
    -----
    splint silently assumes that the spline function is zero outside the data
    interval (a, b).
    
    See Also
    --------
    splprep, splrep, sproot, spalde, splev
    bisplrep, bisplev
    UnivariateSpline, BivariateSpline
    
    References
    ----------
    .. [1] P.W. Gaffney, The calculation of indefinite integrals of b-splines"",
        J. Inst. Maths Applics, 17, p.37-41, 1976.
    .. [2] P. Dierckx, ""Curve and surface fitting with splines"", Monographs
        on Numerical Analysis, Oxford University Press, 1993.
",function,"('(a, b, tck, full_output=0)',)",scipy,1.1.0,scipy.interpolate._fitpack_impl.splint,interpolate._fitpack_impl,splint,"Python Library Documentation: function splint in module scipy.interpolate._fitpack_impl

splint(a, b, tck, full_output=0)
    Evaluate the definite integral of a B-spline.
    
    Given the knots and coefficients of a B-spline, evaluate the definite
    integral of the smoothing polynomial between two given points.
    
    Parameters
    ----------
    a, b : float
        The end-points of the integration interval.
    tck : tuple
        A tuple (t,c,k) containing the vector of knots, the B-spline
        coefficients, and the degree of the spline (see `splev`).
    full_output : int, optional
        Non-zero to return optional output.
    
    Returns
    -------
    integral : float
        The resulting integral.
    wrk : ndarray
        An array containing the integrals of the normalized B-splines
        defined on the set of knots.
    
    Notes
    -----
    splint silently assumes that the spline function is zero outside the data
    interval (a, b).
    
    See Also
    --------
    splprep, splrep, sproot, spalde, splev
    bisplrep, bisplev
    UnivariateSpline, BivariateSpline
    
    References
    ----------
    .. [1] P.W. Gaffney, The calculation of indefinite integrals of b-splines"",
        J. Inst. Maths Applics, 17, p.37-41, 1976.
    .. [2] P. Dierckx, ""Curve and surface fitting with splines"", Monographs
        on Numerical Analysis, Oxford University Press, 1993.
",function,"('a', 'b', 'tck', 'full_output')","(nan, nan, nan, 0)","(nan, nan, nan, 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, b, tck, full_output=0)',)"
scipy,1.1.0,scipy.interpolate._fitpack_impl.splprep,interpolate._fitpack_impl,splprep,"Python Library Documentation: function splprep in module scipy.interpolate._fitpack_impl

splprep(x, w=None, u=None, ub=None, ue=None, k=3, task=0, s=None, t=None, full_output=0, nest=None, per=0, quiet=1)
    Find the B-spline representation of an N-dimensional curve.
    
    Given a list of N rank-1 arrays, `x`, which represent a curve in
    N-dimensional space parametrized by `u`, find a smooth approximating
    spline curve g(`u`). Uses the FORTRAN routine parcur from FITPACK.
    
    Parameters
    ----------
    x : array_like
        A list of sample vector arrays representing the curve.
    w : array_like, optional
        Strictly positive rank-1 array of weights the same length as `x[0]`.
        The weights are used in computing the weighted least-squares spline
        fit. If the errors in the `x` values have standard-deviation given by
        the vector d, then `w` should be 1/d. Default is ``ones(len(x[0]))``.
    u : array_like, optional
        An array of parameter values. If not given, these values are
        calculated automatically as ``M = len(x[0])``, where
    
            v[0] = 0
    
            v[i] = v[i-1] + distance(`x[i]`, `x[i-1]`)
    
            u[i] = v[i] / v[M-1]
    
    ub, ue : int, optional
        The end-points of the parameters interval.  Defaults to
        u[0] and u[-1].
    k : int, optional
        Degree of the spline. Cubic splines are recommended.
        Even values of `k` should be avoided especially with a small s-value.
        ``1 <= k <= 5``, default is 3.
    task : int, optional
        If task==0 (default), find t and c for a given smoothing factor, s.
        If task==1, find t and c for another value of the smoothing factor, s.
        There must have been a previous call with task=0 or task=1
        for the same set of data.
        If task=-1 find the weighted least square spline for a given set of
        knots, t.
    s : float, optional
        A smoothing condition.  The amount of smoothness is determined by
        satisfying the conditions: ``sum((w * (y - g))**2,axis=0) <= s``,
        where g(x) is the smoothed interpolation of (x,y).  The user can
        use `s` to control the trade-off between closeness and smoothness
        of fit.  Larger `s` means more smoothing while smaller values of `s`
        indicate less smoothing. Recommended values of `s` depend on the
        weights, w.  If the weights represent the inverse of the
        standard-deviation of y, then a good `s` value should be found in
        the range ``(m-sqrt(2*m),m+sqrt(2*m))``, where m is the number of
        data points in x, y, and w.
    t : int, optional
        The knots needed for task=-1.
    full_output : int, optional
        If non-zero, then return optional outputs.
    nest : int, optional
        An over-estimate of the total number of knots of the spline to
        help in determining the storage space.  By default nest=m/2.
        Always large enough is nest=m+k+1.
    per : int, optional
       If non-zero, data points are considered periodic with period
       ``x[m-1] - x[0]`` and a smooth periodic spline approximation is
       returned.  Values of ``y[m-1]`` and ``w[m-1]`` are not used.
    quiet : int, optional
         Non-zero to suppress messages.
         This parameter is deprecated; use standard Python warning filters
         instead.
    
    Returns
    -------
    tck : tuple
        A tuple (t,c,k) containing the vector of knots, the B-spline
        coefficients, and the degree of the spline.
    u : array
        An array of the values of the parameter.
    fp : float
        The weighted sum of squared residuals of the spline approximation.
    ier : int
        An integer flag about splrep success.  Success is indicated
        if ier<=0. If ier in [1,2,3] an error occurred but was not raised.
        Otherwise an error is raised.
    msg : str
        A message corresponding to the integer flag, ier.
    
    See Also
    --------
    splrep, splev, sproot, spalde, splint,
    bisplrep, bisplev
    UnivariateSpline, BivariateSpline
    
    Notes
    -----
    See `splev` for evaluation of the spline and its derivatives.
    The number of dimensions N must be smaller than 11.
    
    References
    ----------
    .. [1] P. Dierckx, ""Algorithms for smoothing data with periodic and
        parametric splines, Computer Graphics and Image Processing"",
        20 (1982) 171-184.
    .. [2] P. Dierckx, ""Algorithms for smoothing data with periodic and
        parametric splines"", report tw55, Dept. Computer Science,
        K.U.Leuven, 1981.
    .. [3] P. Dierckx, ""Curve and surface fitting with splines"", Monographs on
        Numerical Analysis, Oxford University Press, 1993.
",function,"('(x, w=None, u=None, ub=None, ue=None, k=3, task=0, s=None, t=None, full_output=0, nest=None, per=0, quiet=1)',)",scipy,1.1.0,scipy.interpolate._fitpack_impl.splprep,interpolate._fitpack_impl,splprep,"Python Library Documentation: function splprep in module scipy.interpolate._fitpack_impl

splprep(x, w=None, u=None, ub=None, ue=None, k=3, task=0, s=None, t=None, full_output=0, nest=None, per=0, quiet=1)
    Find the B-spline representation of an N-dimensional curve.
    
    Given a list of N rank-1 arrays, `x`, which represent a curve in
    N-dimensional space parametrized by `u`, find a smooth approximating
    spline curve g(`u`). Uses the FORTRAN routine parcur from FITPACK.
    
    Parameters
    ----------
    x : array_like
        A list of sample vector arrays representing the curve.
    w : array_like, optional
        Strictly positive rank-1 array of weights the same length as `x[0]`.
        The weights are used in computing the weighted least-squares spline
        fit. If the errors in the `x` values have standard-deviation given by
        the vector d, then `w` should be 1/d. Default is ``ones(len(x[0]))``.
    u : array_like, optional
        An array of parameter values. If not given, these values are
        calculated automatically as ``M = len(x[0])``, where
    
            v[0] = 0
    
            v[i] = v[i-1] + distance(`x[i]`, `x[i-1]`)
    
            u[i] = v[i] / v[M-1]
    
    ub, ue : int, optional
        The end-points of the parameters interval.  Defaults to
        u[0] and u[-1].
    k : int, optional
        Degree of the spline. Cubic splines are recommended.
        Even values of `k` should be avoided especially with a small s-value.
        ``1 <= k <= 5``, default is 3.
    task : int, optional
        If task==0 (default), find t and c for a given smoothing factor, s.
        If task==1, find t and c for another value of the smoothing factor, s.
        There must have been a previous call with task=0 or task=1
        for the same set of data.
        If task=-1 find the weighted least square spline for a given set of
        knots, t.
    s : float, optional
        A smoothing condition.  The amount of smoothness is determined by
        satisfying the conditions: ``sum((w * (y - g))**2,axis=0) <= s``,
        where g(x) is the smoothed interpolation of (x,y).  The user can
        use `s` to control the trade-off between closeness and smoothness
        of fit.  Larger `s` means more smoothing while smaller values of `s`
        indicate less smoothing. Recommended values of `s` depend on the
        weights, w.  If the weights represent the inverse of the
        standard-deviation of y, then a good `s` value should be found in
        the range ``(m-sqrt(2*m),m+sqrt(2*m))``, where m is the number of
        data points in x, y, and w.
    t : int, optional
        The knots needed for task=-1.
    full_output : int, optional
        If non-zero, then return optional outputs.
    nest : int, optional
        An over-estimate of the total number of knots of the spline to
        help in determining the storage space.  By default nest=m/2.
        Always large enough is nest=m+k+1.
    per : int, optional
       If non-zero, data points are considered periodic with period
       ``x[m-1] - x[0]`` and a smooth periodic spline approximation is
       returned.  Values of ``y[m-1]`` and ``w[m-1]`` are not used.
    quiet : int, optional
         Non-zero to suppress messages.
         This parameter is deprecated; use standard Python warning filters
         instead.
    
    Returns
    -------
    tck : tuple
        A tuple (t,c,k) containing the vector of knots, the B-spline
        coefficients, and the degree of the spline.
    u : array
        An array of the values of the parameter.
    fp : float
        The weighted sum of squared residuals of the spline approximation.
    ier : int
        An integer flag about splrep success.  Success is indicated
        if ier<=0. If ier in [1,2,3] an error occurred but was not raised.
        Otherwise an error is raised.
    msg : str
        A message corresponding to the integer flag, ier.
    
    See Also
    --------
    splrep, splev, sproot, spalde, splint,
    bisplrep, bisplev
    UnivariateSpline, BivariateSpline
    
    Notes
    -----
    See `splev` for evaluation of the spline and its derivatives.
    The number of dimensions N must be smaller than 11.
    
    References
    ----------
    .. [1] P. Dierckx, ""Algorithms for smoothing data with periodic and
        parametric splines, Computer Graphics and Image Processing"",
        20 (1982) 171-184.
    .. [2] P. Dierckx, ""Algorithms for smoothing data with periodic and
        parametric splines"", report tw55, Dept. Computer Science,
        K.U.Leuven, 1981.
    .. [3] P. Dierckx, ""Curve and surface fitting with splines"", Monographs on
        Numerical Analysis, Oxford University Press, 1993.
",function,"('x', 'w', 'u', 'ub', 'ue', 'k', 'task', 's', 't', 'full_output', 'nest', 'per', 'quiet')","(nan, None, None, None, None, 3, 0, None, None, 0, None, 0, 1)","(nan, 'NoneType', 'NoneType', 'NoneType', 'NoneType', 'int', 'int', 'NoneType', 'NoneType', 'int', 'NoneType', 'int', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, w=None, u=None, ub=None, ue=None, k=3, task=0, s=None, t=None, full_output=0, nest=None, per=0, quiet=1)',)"
scipy,1.1.0,scipy.interpolate._fitpack_impl.splrep,interpolate._fitpack_impl,splrep,"Python Library Documentation: function splrep in module scipy.interpolate._fitpack_impl

splrep(x, y, w=None, xb=None, xe=None, k=3, task=0, s=None, t=None, full_output=0, per=0, quiet=1)
    Find the B-spline representation of 1-D curve.
    
    Given the set of data points ``(x[i], y[i])`` determine a smooth spline
    approximation of degree k on the interval ``xb <= x <= xe``.
    
    Parameters
    ----------
    x, y : array_like
        The data points defining a curve y = f(x).
    w : array_like, optional
        Strictly positive rank-1 array of weights the same length as x and y.
        The weights are used in computing the weighted least-squares spline
        fit. If the errors in the y values have standard-deviation given by the
        vector d, then w should be 1/d. Default is ones(len(x)).
    xb, xe : float, optional
        The interval to fit.  If None, these default to x[0] and x[-1]
        respectively.
    k : int, optional
        The order of the spline fit. It is recommended to use cubic splines.
        Even order splines should be avoided especially with small s values.
        1 <= k <= 5
    task : {1, 0, -1}, optional
        If task==0 find t and c for a given smoothing factor, s.
    
        If task==1 find t and c for another value of the smoothing factor, s.
        There must have been a previous call with task=0 or task=1 for the same
        set of data (t will be stored an used internally)
    
        If task=-1 find the weighted least square spline for a given set of
        knots, t. These should be interior knots as knots on the ends will be
        added automatically.
    s : float, optional
        A smoothing condition. The amount of smoothness is determined by
        satisfying the conditions: sum((w * (y - g))**2,axis=0) <= s where g(x)
        is the smoothed interpolation of (x,y). The user can use s to control
        the tradeoff between closeness and smoothness of fit. Larger s means
        more smoothing while smaller values of s indicate less smoothing.
        Recommended values of s depend on the weights, w. If the weights
        represent the inverse of the standard-deviation of y, then a good s
        value should be found in the range (m-sqrt(2*m),m+sqrt(2*m)) where m is
        the number of datapoints in x, y, and w. default : s=m-sqrt(2*m) if
        weights are supplied. s = 0.0 (interpolating) if no weights are
        supplied.
    t : array_like, optional
        The knots needed for task=-1. If given then task is automatically set
        to -1.
    full_output : bool, optional
        If non-zero, then return optional outputs.
    per : bool, optional
        If non-zero, data points are considered periodic with period x[m-1] -
        x[0] and a smooth periodic spline approximation is returned. Values of
        y[m-1] and w[m-1] are not used.
    quiet : bool, optional
        Non-zero to suppress messages.
        This parameter is deprecated; use standard Python warning filters
        instead.
    
    Returns
    -------
    tck : tuple
        (t,c,k) a tuple containing the vector of knots, the B-spline
        coefficients, and the degree of the spline.
    fp : array, optional
        The weighted sum of squared residuals of the spline approximation.
    ier : int, optional
        An integer flag about splrep success. Success is indicated if ier<=0.
        If ier in [1,2,3] an error occurred but was not raised. Otherwise an
        error is raised.
    msg : str, optional
        A message corresponding to the integer flag, ier.
    
    Notes
    -----
    See splev for evaluation of the spline and its derivatives.
    
    The user is responsible for assuring that the values of *x* are unique.
    Otherwise, *splrep* will not return sensible results.
    
    See Also
    --------
    UnivariateSpline, BivariateSpline
    splprep, splev, sproot, spalde, splint
    bisplrep, bisplev
    
    Notes
    -----
    See splev for evaluation of the spline and its derivatives. Uses the
    FORTRAN routine curfit from FITPACK.
    
    If provided, knots `t` must satisfy the Schoenberg-Whitney conditions,
    i.e., there must be a subset of data points ``x[j]`` such that
    ``t[j] < x[j] < t[j+k+1]``, for ``j=0, 1,...,n-k-2``.
    
    References
    ----------
    Based on algorithms described in [1]_, [2]_, [3]_, and [4]_:
    
    .. [1] P. Dierckx, ""An algorithm for smoothing, differentiation and
       integration of experimental data using spline functions"",
       J.Comp.Appl.Maths 1 (1975) 165-184.
    .. [2] P. Dierckx, ""A fast algorithm for smoothing data on a rectangular
       grid while using spline functions"", SIAM J.Numer.Anal. 19 (1982)
       1286-1304.
    .. [3] P. Dierckx, ""An improved algorithm for curve fitting with spline
       functions"", report tw54, Dept. Computer Science,K.U. Leuven, 1981.
    .. [4] P. Dierckx, ""Curve and surface fitting with splines"", Monographs on
       Numerical Analysis, Oxford University Press, 1993.
    
    Examples
    --------
    
    >>> import matplotlib.pyplot as plt
    >>> from scipy.interpolate import splev, splrep
    >>> x = np.linspace(0, 10, 10)
    >>> y = np.sin(x)
    >>> tck = splrep(x, y)
    >>> x2 = np.linspace(0, 10, 200)
    >>> y2 = splev(x2, tck)
    >>> plt.plot(x, y, 'o', x2, y2)
    >>> plt.show()
",function,"('(x, y, w=None, xb=None, xe=None, k=3, task=0, s=None, t=None, full_output=0, per=0, quiet=1)',)",scipy,1.1.0,scipy.interpolate._fitpack_impl.splrep,interpolate._fitpack_impl,splrep,"Python Library Documentation: function splrep in module scipy.interpolate._fitpack_impl

splrep(x, y, w=None, xb=None, xe=None, k=3, task=0, s=None, t=None, full_output=0, per=0, quiet=1)
    Find the B-spline representation of 1-D curve.
    
    Given the set of data points ``(x[i], y[i])`` determine a smooth spline
    approximation of degree k on the interval ``xb <= x <= xe``.
    
    Parameters
    ----------
    x, y : array_like
        The data points defining a curve y = f(x).
    w : array_like, optional
        Strictly positive rank-1 array of weights the same length as x and y.
        The weights are used in computing the weighted least-squares spline
        fit. If the errors in the y values have standard-deviation given by the
        vector d, then w should be 1/d. Default is ones(len(x)).
    xb, xe : float, optional
        The interval to fit.  If None, these default to x[0] and x[-1]
        respectively.
    k : int, optional
        The order of the spline fit. It is recommended to use cubic splines.
        Even order splines should be avoided especially with small s values.
        1 <= k <= 5
    task : {1, 0, -1}, optional
        If task==0 find t and c for a given smoothing factor, s.
    
        If task==1 find t and c for another value of the smoothing factor, s.
        There must have been a previous call with task=0 or task=1 for the same
        set of data (t will be stored an used internally)
    
        If task=-1 find the weighted least square spline for a given set of
        knots, t. These should be interior knots as knots on the ends will be
        added automatically.
    s : float, optional
        A smoothing condition. The amount of smoothness is determined by
        satisfying the conditions: sum((w * (y - g))**2,axis=0) <= s where g(x)
        is the smoothed interpolation of (x,y). The user can use s to control
        the tradeoff between closeness and smoothness of fit. Larger s means
        more smoothing while smaller values of s indicate less smoothing.
        Recommended values of s depend on the weights, w. If the weights
        represent the inverse of the standard-deviation of y, then a good s
        value should be found in the range (m-sqrt(2*m),m+sqrt(2*m)) where m is
        the number of datapoints in x, y, and w. default : s=m-sqrt(2*m) if
        weights are supplied. s = 0.0 (interpolating) if no weights are
        supplied.
    t : array_like, optional
        The knots needed for task=-1. If given then task is automatically set
        to -1.
    full_output : bool, optional
        If non-zero, then return optional outputs.
    per : bool, optional
        If non-zero, data points are considered periodic with period x[m-1] -
        x[0] and a smooth periodic spline approximation is returned. Values of
        y[m-1] and w[m-1] are not used.
    quiet : bool, optional
        Non-zero to suppress messages.
        This parameter is deprecated; use standard Python warning filters
        instead.
    
    Returns
    -------
    tck : tuple
        (t,c,k) a tuple containing the vector of knots, the B-spline
        coefficients, and the degree of the spline.
    fp : array, optional
        The weighted sum of squared residuals of the spline approximation.
    ier : int, optional
        An integer flag about splrep success. Success is indicated if ier<=0.
        If ier in [1,2,3] an error occurred but was not raised. Otherwise an
        error is raised.
    msg : str, optional
        A message corresponding to the integer flag, ier.
    
    Notes
    -----
    See splev for evaluation of the spline and its derivatives.
    
    The user is responsible for assuring that the values of *x* are unique.
    Otherwise, *splrep* will not return sensible results.
    
    See Also
    --------
    UnivariateSpline, BivariateSpline
    splprep, splev, sproot, spalde, splint
    bisplrep, bisplev
    
    Notes
    -----
    See splev for evaluation of the spline and its derivatives. Uses the
    FORTRAN routine curfit from FITPACK.
    
    If provided, knots `t` must satisfy the Schoenberg-Whitney conditions,
    i.e., there must be a subset of data points ``x[j]`` such that
    ``t[j] < x[j] < t[j+k+1]``, for ``j=0, 1,...,n-k-2``.
    
    References
    ----------
    Based on algorithms described in [1]_, [2]_, [3]_, and [4]_:
    
    .. [1] P. Dierckx, ""An algorithm for smoothing, differentiation and
       integration of experimental data using spline functions"",
       J.Comp.Appl.Maths 1 (1975) 165-184.
    .. [2] P. Dierckx, ""A fast algorithm for smoothing data on a rectangular
       grid while using spline functions"", SIAM J.Numer.Anal. 19 (1982)
       1286-1304.
    .. [3] P. Dierckx, ""An improved algorithm for curve fitting with spline
       functions"", report tw54, Dept. Computer Science,K.U. Leuven, 1981.
    .. [4] P. Dierckx, ""Curve and surface fitting with splines"", Monographs on
       Numerical Analysis, Oxford University Press, 1993.
    
    Examples
    --------
    
    >>> import matplotlib.pyplot as plt
    >>> from scipy.interpolate import splev, splrep
    >>> x = np.linspace(0, 10, 10)
    >>> y = np.sin(x)
    >>> tck = splrep(x, y)
    >>> x2 = np.linspace(0, 10, 200)
    >>> y2 = splev(x2, tck)
    >>> plt.plot(x, y, 'o', x2, y2)
    >>> plt.show()
",function,"('x', 'y', 'w', 'xb', 'xe', 'k', 'task', 's', 't', 'full_output', 'per', 'quiet')","(nan, nan, None, None, None, 3, 0, None, None, 0, 0, 1)","(nan, nan, 'NoneType', 'NoneType', 'NoneType', 'int', 'int', 'NoneType', 'NoneType', 'int', 'int', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, y, w=None, xb=None, xe=None, k=3, task=0, s=None, t=None, full_output=0, per=0, quiet=1)',)"
scipy,1.1.0,scipy.interpolate._fitpack_impl.sproot,interpolate._fitpack_impl,sproot,"Python Library Documentation: function sproot in module scipy.interpolate._fitpack_impl

sproot(tck, mest=10)
    Find the roots of a cubic B-spline.
    
    Given the knots (>=8) and coefficients of a cubic B-spline return the
    roots of the spline.
    
    Parameters
    ----------
    tck : tuple
        A tuple (t,c,k) containing the vector of knots,
        the B-spline coefficients, and the degree of the spline.
        The number of knots must be >= 8, and the degree must be 3.
        The knots must be a montonically increasing sequence.
    mest : int, optional
        An estimate of the number of zeros (Default is 10).
    
    Returns
    -------
    zeros : ndarray
        An array giving the roots of the spline.
    
    See also
    --------
    splprep, splrep, splint, spalde, splev
    bisplrep, bisplev
    UnivariateSpline, BivariateSpline
    
    
    References
    ----------
    .. [1] C. de Boor, ""On calculating with b-splines"", J. Approximation
        Theory, 6, p.50-62, 1972.
    .. [2] M.G. Cox, ""The numerical evaluation of b-splines"", J. Inst. Maths
        Applics, 10, p.134-149, 1972.
    .. [3] P. Dierckx, ""Curve and surface fitting with splines"", Monographs
        on Numerical Analysis, Oxford University Press, 1993.
",function,"('(tck, mest=10)',)",scipy,1.1.0,scipy.interpolate._fitpack_impl.sproot,interpolate._fitpack_impl,sproot,"Python Library Documentation: function sproot in module scipy.interpolate._fitpack_impl

sproot(tck, mest=10)
    Find the roots of a cubic B-spline.
    
    Given the knots (>=8) and coefficients of a cubic B-spline return the
    roots of the spline.
    
    Parameters
    ----------
    tck : tuple
        A tuple (t,c,k) containing the vector of knots,
        the B-spline coefficients, and the degree of the spline.
        The number of knots must be >= 8, and the degree must be 3.
        The knots must be a montonically increasing sequence.
    mest : int, optional
        An estimate of the number of zeros (Default is 10).
    
    Returns
    -------
    zeros : ndarray
        An array giving the roots of the spline.
    
    See also
    --------
    splprep, splrep, splint, spalde, splev
    bisplrep, bisplev
    UnivariateSpline, BivariateSpline
    
    
    References
    ----------
    .. [1] C. de Boor, ""On calculating with b-splines"", J. Approximation
        Theory, 6, p.50-62, 1972.
    .. [2] M.G. Cox, ""The numerical evaluation of b-splines"", J. Inst. Maths
        Applics, 10, p.134-149, 1972.
    .. [3] P. Dierckx, ""Curve and surface fitting with splines"", Monographs
        on Numerical Analysis, Oxford University Press, 1993.
",function,"('tck', 'mest')","(nan, 10)","(nan, 'int')","('arg_info', 'arg_info')","('(tck, mest=10)',)"
scipy,1.1.0,scipy.interpolate._fitpack_impl.transpose,interpolate._fitpack_impl,transpose,"Python Library Documentation: function transpose in module numpy.core.fromnumeric

transpose(a, axes=None)
    Permute the dimensions of an array.
    
    Parameters
    ----------
    a : array_like
        Input array.
    axes : list of ints, optional
        By default, reverse the dimensions, otherwise permute the axes
        according to the values given.
    
    Returns
    -------
    p : ndarray
        `a` with its axes permuted.  A view is returned whenever
        possible.
    
    See Also
    --------
    moveaxis
    argsort
    
    Notes
    -----
    Use `transpose(a, argsort(axes))` to invert the transposition of tensors
    when using the `axes` keyword argument.
    
    Transposing a 1-D array returns an unchanged view of the original array.
    
    Examples
    --------
    >>> x = np.arange(4).reshape((2,2))
    >>> x
    array([[0, 1],
           [2, 3]])
    
    >>> np.transpose(x)
    array([[0, 2],
           [1, 3]])
    
    >>> x = np.ones((1, 2, 3))
    >>> np.transpose(x, (1, 0, 2)).shape
    (2, 1, 3)
",function,"('(a, axes=None)',)",scipy,1.1.0,scipy.interpolate._fitpack_impl.transpose,interpolate._fitpack_impl,transpose,"Python Library Documentation: function transpose in module numpy.core.fromnumeric

transpose(a, axes=None)
    Permute the dimensions of an array.
    
    Parameters
    ----------
    a : array_like
        Input array.
    axes : list of ints, optional
        By default, reverse the dimensions, otherwise permute the axes
        according to the values given.
    
    Returns
    -------
    p : ndarray
        `a` with its axes permuted.  A view is returned whenever
        possible.
    
    See Also
    --------
    moveaxis
    argsort
    
    Notes
    -----
    Use `transpose(a, argsort(axes))` to invert the transposition of tensors
    when using the `axes` keyword argument.
    
    Transposing a 1-D array returns an unchanged view of the original array.
    
    Examples
    --------
    >>> x = np.arange(4).reshape((2,2))
    >>> x
    array([[0, 1],
           [2, 3]])
    
    >>> np.transpose(x)
    array([[0, 2],
           [1, 3]])
    
    >>> x = np.ones((1, 2, 3))
    >>> np.transpose(x, (1, 0, 2)).shape
    (2, 1, 3)
",function,"('a', 'axes')","(nan, None)","(nan, 'NoneType')","('arg_info', 'arg_info')","('(a, axes=None)',)"
scipy,1.1.0,scipy.interpolate._pade.asarray,interpolate._pade,asarray,"Python Library Documentation: function asarray in module numpy.core.numeric

asarray(a, dtype=None, order=None)
    Convert the input to an array.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
        Whether to use row-major (C-style) or
        column-major (Fortran-style) memory representation.
        Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray with matching dtype and order.  If `a` is a
        subclass of ndarray, a base class ndarray is returned.
    
    See Also
    --------
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    asarray_chkfinite : Similar function which checks input for NaNs and Infs.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array:
    
    >>> a = [1, 2]
    >>> np.asarray(a)
    array([1, 2])
    
    Existing arrays are not copied:
    
    >>> a = np.array([1, 2])
    >>> np.asarray(a) is a
    True
    
    If `dtype` is set, array is copied only if dtype does not match:
    
    >>> a = np.array([1, 2], dtype=np.float32)
    >>> np.asarray(a, dtype=np.float32) is a
    True
    >>> np.asarray(a, dtype=np.float64) is a
    False
    
    Contrary to `asanyarray`, ndarray subclasses are not passed through:
    
    >>> issubclass(np.matrix, np.ndarray)
    True
    >>> a = np.matrix([[1, 2]])
    >>> np.asarray(a) is a
    False
    >>> np.asanyarray(a) is a
    True
",function,"('(a, dtype=None, order=None)',)",scipy,1.1.0,scipy.interpolate._pade.asarray,interpolate._pade,asarray,"Python Library Documentation: function asarray in module numpy.core.numeric

asarray(a, dtype=None, order=None)
    Convert the input to an array.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
        Whether to use row-major (C-style) or
        column-major (Fortran-style) memory representation.
        Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray with matching dtype and order.  If `a` is a
        subclass of ndarray, a base class ndarray is returned.
    
    See Also
    --------
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    asarray_chkfinite : Similar function which checks input for NaNs and Infs.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array:
    
    >>> a = [1, 2]
    >>> np.asarray(a)
    array([1, 2])
    
    Existing arrays are not copied:
    
    >>> a = np.array([1, 2])
    >>> np.asarray(a) is a
    True
    
    If `dtype` is set, array is copied only if dtype does not match:
    
    >>> a = np.array([1, 2], dtype=np.float32)
    >>> np.asarray(a, dtype=np.float32) is a
    True
    >>> np.asarray(a, dtype=np.float64) is a
    False
    
    Contrary to `asanyarray`, ndarray subclasses are not passed through:
    
    >>> issubclass(np.matrix, np.ndarray)
    True
    >>> a = np.matrix([[1, 2]])
    >>> np.asarray(a) is a
    False
    >>> np.asanyarray(a) is a
    True
",function,"('a', 'dtype', 'order')","(nan, None, None)","(nan, 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(a, dtype=None, order=None)',)"
scipy,1.1.0,scipy.interpolate._pade.eye,interpolate._pade,eye,"Python Library Documentation: function eye in module numpy.lib.twodim_base

eye(N, M=None, k=0, dtype=<class 'float'>, order='C')
    Return a 2-D array with ones on the diagonal and zeros elsewhere.
    
    Parameters
    ----------
    N : int
      Number of rows in the output.
    M : int, optional
      Number of columns in the output. If None, defaults to `N`.
    k : int, optional
      Index of the diagonal: 0 (the default) refers to the main diagonal,
      a positive value refers to an upper diagonal, and a negative value
      to a lower diagonal.
    dtype : data-type, optional
      Data-type of the returned array.
    order : {'C', 'F'}, optional
        Whether the output should be stored in row-major (C-style) or
        column-major (Fortran-style) order in memory.
    
        .. versionadded:: 1.14.0
    
    Returns
    -------
    I : ndarray of shape (N,M)
      An array where all elements are equal to zero, except for the `k`-th
      diagonal, whose values are equal to one.
    
    See Also
    --------
    identity : (almost) equivalent function
    diag : diagonal 2-D array from a 1-D array specified by the user.
    
    Examples
    --------
    >>> np.eye(2, dtype=int)
    array([[1, 0],
           [0, 1]])
    >>> np.eye(3, k=1)
    array([[ 0.,  1.,  0.],
           [ 0.,  0.,  1.],
           [ 0.,  0.,  0.]])
",function,"(""(N, M=None, k=0, dtype=<class 'float'>, order='C')"",)",scipy,1.1.0,scipy.interpolate._pade.eye,interpolate._pade,eye,"Python Library Documentation: function eye in module numpy.lib.twodim_base

eye(N, M=None, k=0, dtype=<class 'float'>, order='C')
    Return a 2-D array with ones on the diagonal and zeros elsewhere.
    
    Parameters
    ----------
    N : int
      Number of rows in the output.
    M : int, optional
      Number of columns in the output. If None, defaults to `N`.
    k : int, optional
      Index of the diagonal: 0 (the default) refers to the main diagonal,
      a positive value refers to an upper diagonal, and a negative value
      to a lower diagonal.
    dtype : data-type, optional
      Data-type of the returned array.
    order : {'C', 'F'}, optional
        Whether the output should be stored in row-major (C-style) or
        column-major (Fortran-style) order in memory.
    
        .. versionadded:: 1.14.0
    
    Returns
    -------
    I : ndarray of shape (N,M)
      An array where all elements are equal to zero, except for the `k`-th
      diagonal, whose values are equal to one.
    
    See Also
    --------
    identity : (almost) equivalent function
    diag : diagonal 2-D array from a 1-D array specified by the user.
    
    Examples
    --------
    >>> np.eye(2, dtype=int)
    array([[1, 0],
           [0, 1]])
    >>> np.eye(3, k=1)
    array([[ 0.,  1.,  0.],
           [ 0.,  0.,  1.],
           [ 0.,  0.,  0.]])
",function,"('N', 'M', 'k', 'dtype', 'order')","(nan, None, 0, <class 'float'>, 'C')","(nan, 'NoneType', 'int', 'type', 'str')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(N, M=None, k=0, dtype=<class 'float'>, order='C')"",)"
scipy,1.1.0,scipy.interpolate._pade.hstack,interpolate._pade,hstack,"Python Library Documentation: function hstack in module numpy.core.shape_base

hstack(tup)
    Stack arrays in sequence horizontally (column wise).
    
    This is equivalent to concatenation along the second axis, except for 1-D
    arrays where it concatenates along the first axis. Rebuilds arrays divided
    by `hsplit`.
    
    This function makes most sense for arrays with up to 3 dimensions. For
    instance, for pixel-data with a height (first axis), width (second axis),
    and r/g/b channels (third axis). The functions `concatenate`, `stack` and
    `block` provide more general stacking and concatenation operations.
    
    Parameters
    ----------
    tup : sequence of ndarrays
        The arrays must have the same shape along all but the second axis,
        except 1-D arrays which can be any length.
    
    Returns
    -------
    stacked : ndarray
        The array formed by stacking the given arrays.
    
    See Also
    --------
    stack : Join a sequence of arrays along a new axis.
    vstack : Stack arrays in sequence vertically (row wise).
    dstack : Stack arrays in sequence depth wise (along third axis).
    concatenate : Join a sequence of arrays along an existing axis.
    hsplit : Split array along second axis.
    block : Assemble arrays from blocks.
    
    Examples
    --------
    >>> a = np.array((1,2,3))
    >>> b = np.array((2,3,4))
    >>> np.hstack((a,b))
    array([1, 2, 3, 2, 3, 4])
    >>> a = np.array([[1],[2],[3]])
    >>> b = np.array([[2],[3],[4]])
    >>> np.hstack((a,b))
    array([[1, 2],
           [2, 3],
           [3, 4]])
",function,"('(tup)',)",scipy,1.1.0,scipy.interpolate._pade.hstack,interpolate._pade,hstack,"Python Library Documentation: function hstack in module numpy.core.shape_base

hstack(tup)
    Stack arrays in sequence horizontally (column wise).
    
    This is equivalent to concatenation along the second axis, except for 1-D
    arrays where it concatenates along the first axis. Rebuilds arrays divided
    by `hsplit`.
    
    This function makes most sense for arrays with up to 3 dimensions. For
    instance, for pixel-data with a height (first axis), width (second axis),
    and r/g/b channels (third axis). The functions `concatenate`, `stack` and
    `block` provide more general stacking and concatenation operations.
    
    Parameters
    ----------
    tup : sequence of ndarrays
        The arrays must have the same shape along all but the second axis,
        except 1-D arrays which can be any length.
    
    Returns
    -------
    stacked : ndarray
        The array formed by stacking the given arrays.
    
    See Also
    --------
    stack : Join a sequence of arrays along a new axis.
    vstack : Stack arrays in sequence vertically (row wise).
    dstack : Stack arrays in sequence depth wise (along third axis).
    concatenate : Join a sequence of arrays along an existing axis.
    hsplit : Split array along second axis.
    block : Assemble arrays from blocks.
    
    Examples
    --------
    >>> a = np.array((1,2,3))
    >>> b = np.array((2,3,4))
    >>> np.hstack((a,b))
    array([1, 2, 3, 2, 3, 4])
    >>> a = np.array([[1],[2],[3]])
    >>> b = np.array([[2],[3],[4]])
    >>> np.hstack((a,b))
    array([[1, 2],
           [2, 3],
           [3, 4]])
",function,"('tup',)","(nan,)","(nan,)","('arg_info',)","('(tup)',)"
scipy,1.1.0,scipy.interpolate._pade.pade,interpolate._pade,pade,"Python Library Documentation: function pade in module scipy.interpolate._pade

pade(an, m)
    Return Pade approximation to a polynomial as the ratio of two polynomials.
    
    Parameters
    ----------
    an : (N,) array_like
        Taylor series coefficients.
    m : int
        The order of the returned approximating polynomials.
    
    Returns
    -------
    p, q : Polynomial class
        The Pade approximation of the polynomial defined by `an` is
        ``p(x)/q(x)``.
    
    Examples
    --------
    >>> from scipy.interpolate import pade
    >>> e_exp = [1.0, 1.0, 1.0/2.0, 1.0/6.0, 1.0/24.0, 1.0/120.0]
    >>> p, q = pade(e_exp, 2)
    
    >>> e_exp.reverse()
    >>> e_poly = np.poly1d(e_exp)
    
    Compare ``e_poly(x)`` and the Pade approximation ``p(x)/q(x)``
    
    >>> e_poly(1)
    2.7166666666666668
    
    >>> p(1)/q(1)
    2.7179487179487181
",function,"('(an, m)',)",scipy,1.1.0,scipy.interpolate._pade.pade,interpolate._pade,pade,"Python Library Documentation: function pade in module scipy.interpolate._pade

pade(an, m)
    Return Pade approximation to a polynomial as the ratio of two polynomials.
    
    Parameters
    ----------
    an : (N,) array_like
        Taylor series coefficients.
    m : int
        The order of the returned approximating polynomials.
    
    Returns
    -------
    p, q : Polynomial class
        The Pade approximation of the polynomial defined by `an` is
        ``p(x)/q(x)``.
    
    Examples
    --------
    >>> from scipy.interpolate import pade
    >>> e_exp = [1.0, 1.0, 1.0/2.0, 1.0/6.0, 1.0/24.0, 1.0/120.0]
    >>> p, q = pade(e_exp, 2)
    
    >>> e_exp.reverse()
    >>> e_poly = np.poly1d(e_exp)
    
    Compare ``e_poly(x)`` and the Pade approximation ``p(x)/q(x)``
    
    >>> e_poly(1)
    2.7166666666666668
    
    >>> p(1)/q(1)
    2.7179487179487181
",function,"('an', 'm')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(an, m)',)"
scipy,1.1.0,scipy.interpolate._pade.poly1d,interpolate._pade,poly1d,"Python Library Documentation: class poly1d in module numpy.lib.polynomial

class poly1d(builtins.object)
 |  A one-dimensional polynomial class.
 |  
 |  A convenience class, used to encapsulate ""natural"" operations on
 |  polynomials so that said operations may take on their customary
 |  form in code (see Examples).
 |  
 |  Parameters
 |  ----------
 |  c_or_r : array_like
 |      The polynomial's coefficients, in decreasing powers, or if
 |      the value of the second parameter is True, the polynomial's
 |      roots (values where the polynomial evaluates to 0).  For example,
 |      ``poly1d([1, 2, 3])`` returns an object that represents
 |      :math:`x^2 + 2x + 3`, whereas ``poly1d([1, 2, 3], True)`` returns
 |      one that represents :math:`(x-1)(x-2)(x-3) = x^3 - 6x^2 + 11x -6`.
 |  r : bool, optional
 |      If True, `c_or_r` specifies the polynomial's roots; the default
 |      is False.
 |  variable : str, optional
 |      Changes the variable used when printing `p` from `x` to `variable`
 |      (see Examples).
 |  
 |  Examples
 |  --------
 |  Construct the polynomial :math:`x^2 + 2x + 3`:
 |  
 |  >>> p = np.poly1d([1, 2, 3])
 |  >>> print(np.poly1d(p))
 |     2
 |  1 x + 2 x + 3
 |  
 |  Evaluate the polynomial at :math:`x = 0.5`:
 |  
 |  >>> p(0.5)
 |  4.25
 |  
 |  Find the roots:
 |  
 |  >>> p.r
 |  array([-1.+1.41421356j, -1.-1.41421356j])
 |  >>> p(p.r)
 |  array([ -4.44089210e-16+0.j,  -4.44089210e-16+0.j])
 |  
 |  These numbers in the previous line represent (0, 0) to machine precision
 |  
 |  Show the coefficients:
 |  
 |  >>> p.c
 |  array([1, 2, 3])
 |  
 |  Display the order (the leading zero-coefficients are removed):
 |  
 |  >>> p.order
 |  2
 |  
 |  Show the coefficient of the k-th power in the polynomial
 |  (which is equivalent to ``p.c[-(i+1)]``):
 |  
 |  >>> p[1]
 |  2
 |  
 |  Polynomials can be added, subtracted, multiplied, and divided
 |  (returns quotient and remainder):
 |  
 |  >>> p * p
 |  poly1d([ 1,  4, 10, 12,  9])
 |  
 |  >>> (p**3 + 4) / p
 |  (poly1d([  1.,   4.,  10.,  12.,   9.]), poly1d([ 4.]))
 |  
 |  ``asarray(p)`` gives the coefficient array, so polynomials can be
 |  used in all functions that accept arrays:
 |  
 |  >>> p**2 # square of polynomial
 |  poly1d([ 1,  4, 10, 12,  9])
 |  
 |  >>> np.square(p) # square of individual coefficients
 |  array([1, 4, 9])
 |  
 |  The variable used in the string representation of `p` can be modified,
 |  using the `variable` parameter:
 |  
 |  >>> p = np.poly1d([1,2,3], variable='z')
 |  >>> print(p)
 |     2
 |  1 z + 2 z + 3
 |  
 |  Construct a polynomial from its roots:
 |  
 |  >>> np.poly1d([1, 2], True)
 |  poly1d([ 1, -3,  2])
 |  
 |  This is the same polynomial as obtained by:
 |  
 |  >>> np.poly1d([1, -1]) * np.poly1d([1, -2])
 |  poly1d([ 1, -3,  2])
 |  
 |  Methods defined here:
 |  
 |  __add__(self, other)
 |  
 |  __array__(self, t=None)
 |  
 |  __call__(self, val)
 |      Call self as a function.
 |  
 |  __div__(self, other)
 |  
 |  __eq__(self, other)
 |      Return self==value.
 |  
 |  __getitem__(self, val)
 |  
 |  __init__(self, c_or_r, r=False, variable=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self)
 |  
 |  __len__(self)
 |  
 |  __mul__(self, other)
 |  
 |  __ne__(self, other)
 |      Return self!=value.
 |  
 |  __neg__(self)
 |  
 |  __pos__(self)
 |  
 |  __pow__(self, val)
 |  
 |  __radd__(self, other)
 |  
 |  __rdiv__(self, other)
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __rmul__(self, other)
 |  
 |  __rsub__(self, other)
 |  
 |  __rtruediv__ = __rdiv__(self, other)
 |  
 |  __setitem__(self, key, val)
 |  
 |  __str__(self)
 |      Return str(self).
 |  
 |  __sub__(self, other)
 |  
 |  __truediv__ = __div__(self, other)
 |  
 |  deriv(self, m=1)
 |      Return a derivative of this polynomial.
 |      
 |      Refer to `polyder` for full documentation.
 |      
 |      See Also
 |      --------
 |      polyder : equivalent function
 |  
 |  integ(self, m=1, k=0)
 |      Return an antiderivative (indefinite integral) of this polynomial.
 |      
 |      Refer to `polyint` for full documentation.
 |      
 |      See Also
 |      --------
 |      polyint : equivalent function
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  c
 |      A copy of the polynomial coefficients
 |  
 |  coef
 |      A copy of the polynomial coefficients
 |  
 |  coefficients
 |      A copy of the polynomial coefficients
 |  
 |  coeffs
 |      A copy of the polynomial coefficients
 |  
 |  o
 |      The order or degree of the polynomial
 |  
 |  order
 |      The order or degree of the polynomial
 |  
 |  r
 |      The roots of the polynomial, where self(x) == 0
 |  
 |  roots
 |      The roots of the polynomial, where self(x) == 0
 |  
 |  variable
 |      The name of the polynomial variable
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None
",class,"('(self, c_or_r, r=False, variable=None)',)",scipy,1.1.0,scipy.interpolate._pade.poly1d,interpolate._pade,poly1d,"Python Library Documentation: class poly1d in module numpy.lib.polynomial

class poly1d(builtins.object)
 |  A one-dimensional polynomial class.
 |  
 |  A convenience class, used to encapsulate ""natural"" operations on
 |  polynomials so that said operations may take on their customary
 |  form in code (see Examples).
 |  
 |  Parameters
 |  ----------
 |  c_or_r : array_like
 |      The polynomial's coefficients, in decreasing powers, or if
 |      the value of the second parameter is True, the polynomial's
 |      roots (values where the polynomial evaluates to 0).  For example,
 |      ``poly1d([1, 2, 3])`` returns an object that represents
 |      :math:`x^2 + 2x + 3`, whereas ``poly1d([1, 2, 3], True)`` returns
 |      one that represents :math:`(x-1)(x-2)(x-3) = x^3 - 6x^2 + 11x -6`.
 |  r : bool, optional
 |      If True, `c_or_r` specifies the polynomial's roots; the default
 |      is False.
 |  variable : str, optional
 |      Changes the variable used when printing `p` from `x` to `variable`
 |      (see Examples).
 |  
 |  Examples
 |  --------
 |  Construct the polynomial :math:`x^2 + 2x + 3`:
 |  
 |  >>> p = np.poly1d([1, 2, 3])
 |  >>> print(np.poly1d(p))
 |     2
 |  1 x + 2 x + 3
 |  
 |  Evaluate the polynomial at :math:`x = 0.5`:
 |  
 |  >>> p(0.5)
 |  4.25
 |  
 |  Find the roots:
 |  
 |  >>> p.r
 |  array([-1.+1.41421356j, -1.-1.41421356j])
 |  >>> p(p.r)
 |  array([ -4.44089210e-16+0.j,  -4.44089210e-16+0.j])
 |  
 |  These numbers in the previous line represent (0, 0) to machine precision
 |  
 |  Show the coefficients:
 |  
 |  >>> p.c
 |  array([1, 2, 3])
 |  
 |  Display the order (the leading zero-coefficients are removed):
 |  
 |  >>> p.order
 |  2
 |  
 |  Show the coefficient of the k-th power in the polynomial
 |  (which is equivalent to ``p.c[-(i+1)]``):
 |  
 |  >>> p[1]
 |  2
 |  
 |  Polynomials can be added, subtracted, multiplied, and divided
 |  (returns quotient and remainder):
 |  
 |  >>> p * p
 |  poly1d([ 1,  4, 10, 12,  9])
 |  
 |  >>> (p**3 + 4) / p
 |  (poly1d([  1.,   4.,  10.,  12.,   9.]), poly1d([ 4.]))
 |  
 |  ``asarray(p)`` gives the coefficient array, so polynomials can be
 |  used in all functions that accept arrays:
 |  
 |  >>> p**2 # square of polynomial
 |  poly1d([ 1,  4, 10, 12,  9])
 |  
 |  >>> np.square(p) # square of individual coefficients
 |  array([1, 4, 9])
 |  
 |  The variable used in the string representation of `p` can be modified,
 |  using the `variable` parameter:
 |  
 |  >>> p = np.poly1d([1,2,3], variable='z')
 |  >>> print(p)
 |     2
 |  1 z + 2 z + 3
 |  
 |  Construct a polynomial from its roots:
 |  
 |  >>> np.poly1d([1, 2], True)
 |  poly1d([ 1, -3,  2])
 |  
 |  This is the same polynomial as obtained by:
 |  
 |  >>> np.poly1d([1, -1]) * np.poly1d([1, -2])
 |  poly1d([ 1, -3,  2])
 |  
 |  Methods defined here:
 |  
 |  __add__(self, other)
 |  
 |  __array__(self, t=None)
 |  
 |  __call__(self, val)
 |      Call self as a function.
 |  
 |  __div__(self, other)
 |  
 |  __eq__(self, other)
 |      Return self==value.
 |  
 |  __getitem__(self, val)
 |  
 |  __init__(self, c_or_r, r=False, variable=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self)
 |  
 |  __len__(self)
 |  
 |  __mul__(self, other)
 |  
 |  __ne__(self, other)
 |      Return self!=value.
 |  
 |  __neg__(self)
 |  
 |  __pos__(self)
 |  
 |  __pow__(self, val)
 |  
 |  __radd__(self, other)
 |  
 |  __rdiv__(self, other)
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __rmul__(self, other)
 |  
 |  __rsub__(self, other)
 |  
 |  __rtruediv__ = __rdiv__(self, other)
 |  
 |  __setitem__(self, key, val)
 |  
 |  __str__(self)
 |      Return str(self).
 |  
 |  __sub__(self, other)
 |  
 |  __truediv__ = __div__(self, other)
 |  
 |  deriv(self, m=1)
 |      Return a derivative of this polynomial.
 |      
 |      Refer to `polyder` for full documentation.
 |      
 |      See Also
 |      --------
 |      polyder : equivalent function
 |  
 |  integ(self, m=1, k=0)
 |      Return an antiderivative (indefinite integral) of this polynomial.
 |      
 |      Refer to `polyint` for full documentation.
 |      
 |      See Also
 |      --------
 |      polyint : equivalent function
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  c
 |      A copy of the polynomial coefficients
 |  
 |  coef
 |      A copy of the polynomial coefficients
 |  
 |  coefficients
 |      A copy of the polynomial coefficients
 |  
 |  coeffs
 |      A copy of the polynomial coefficients
 |  
 |  o
 |      The order or degree of the polynomial
 |  
 |  order
 |      The order or degree of the polynomial
 |  
 |  r
 |      The roots of the polynomial, where self(x) == 0
 |  
 |  roots
 |      The roots of the polynomial, where self(x) == 0
 |  
 |  variable
 |      The name of the polynomial variable
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None
",class,"('self', 'c_or_r', 'r', 'variable')","(nan, nan, False, None)","(nan, nan, 'bool', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, c_or_r, r=False, variable=None)',)"
scipy,1.1.0,scipy.interpolate._ppoly._Interpolator1D,interpolate._ppoly,_Interpolator1D,"Python Library Documentation: class _Interpolator1D in module scipy.interpolate.polyint

class _Interpolator1D(builtins.object)
 |  Common features in univariate interpolation
 |  
 |  Deal with input data type and interpolation axis rolling.  The
 |  actual interpolator can assume the y-data is of shape (n, r) where
 |  `n` is the number of x-points, and `r` the number of variables,
 |  and use self.dtype as the y-data type.
 |  
 |  Attributes
 |  ----------
 |  _y_axis
 |      Axis along which the interpolation goes in the original array
 |  _y_extra_shape
 |      Additional trailing shape of the input arrays, excluding
 |      the interpolation axis.
 |  dtype
 |      Dtype of the y-data arrays. Can be set via set_dtype, which
 |      forces it to be float or complex.
 |  
 |  Methods
 |  -------
 |  __call__
 |  _prepare_x
 |  _finish_y
 |  _reshape_yi
 |  _set_yi
 |  _set_dtype
 |  _evaluate
 |  
 |  Methods defined here:
 |  
 |  __call__(self, x)
 |      Evaluate the interpolant
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |  
 |  __init__(self, xi=None, yi=None, axis=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  dtype
",class,"('(self, xi=None, yi=None, axis=None)',)",scipy,1.1.0,scipy.interpolate._ppoly._Interpolator1D,interpolate._ppoly,_Interpolator1D,"Python Library Documentation: class _Interpolator1D in module scipy.interpolate.polyint

class _Interpolator1D(builtins.object)
 |  Common features in univariate interpolation
 |  
 |  Deal with input data type and interpolation axis rolling.  The
 |  actual interpolator can assume the y-data is of shape (n, r) where
 |  `n` is the number of x-points, and `r` the number of variables,
 |  and use self.dtype as the y-data type.
 |  
 |  Attributes
 |  ----------
 |  _y_axis
 |      Axis along which the interpolation goes in the original array
 |  _y_extra_shape
 |      Additional trailing shape of the input arrays, excluding
 |      the interpolation axis.
 |  dtype
 |      Dtype of the y-data arrays. Can be set via set_dtype, which
 |      forces it to be float or complex.
 |  
 |  Methods
 |  -------
 |  __call__
 |  _prepare_x
 |  _finish_y
 |  _reshape_yi
 |  _set_yi
 |  _set_dtype
 |  _evaluate
 |  
 |  Methods defined here:
 |  
 |  __call__(self, x)
 |      Evaluate the interpolant
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |  
 |  __init__(self, xi=None, yi=None, axis=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  dtype
",class,"('self', 'xi', 'yi', 'axis')","(nan, None, None, None)","(nan, 'NoneType', 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, xi=None, yi=None, axis=None)',)"
scipy,1.1.0,scipy.interpolate.fitpack.BSpline,interpolate.fitpack,BSpline,"Python Library Documentation: class BSpline in module scipy.interpolate._bsplines

class BSpline(builtins.object)
 |  Univariate spline in the B-spline basis.
 |  
 |  .. math::
 |  
 |      S(x) = \sum_{j=0}^{n-1} c_j  B_{j, k; t}(x)
 |  
 |  where :math:`B_{j, k; t}` are B-spline basis functions of degree `k`
 |  and knots `t`.
 |  
 |  Parameters
 |  ----------
 |  t : ndarray, shape (n+k+1,)
 |      knots
 |  c : ndarray, shape (>=n, ...)
 |      spline coefficients
 |  k : int
 |      B-spline order
 |  extrapolate : bool or 'periodic', optional
 |      whether to extrapolate beyond the base interval, ``t[k] .. t[n]``,
 |      or to return nans.
 |      If True, extrapolates the first and last polynomial pieces of b-spline
 |      functions active on the base interval.
 |      If 'periodic', periodic extrapolation is used.
 |      Default is True.
 |  axis : int, optional
 |      Interpolation axis. Default is zero.
 |  
 |  Attributes
 |  ----------
 |  t : ndarray
 |      knot vector
 |  c : ndarray
 |      spline coefficients
 |  k : int
 |      spline degree
 |  extrapolate : bool
 |      If True, extrapolates the first and last polynomial pieces of b-spline
 |      functions active on the base interval.
 |  axis : int
 |      Interpolation axis.
 |  tck : tuple
 |      A read-only equivalent of ``(self.t, self.c, self.k)``
 |  
 |  Methods
 |  -------
 |  __call__
 |  basis_element
 |  derivative
 |  antiderivative
 |  integrate
 |  construct_fast
 |  
 |  Notes
 |  -----
 |  B-spline basis elements are defined via
 |  
 |  .. math::
 |  
 |      B_{i, 0}(x) = 1, \textrm{if $t_i \le x < t_{i+1}$, otherwise $0$,}
 |  
 |      B_{i, k}(x) = \frac{x - t_i}{t_{i+k} - t_i} B_{i, k-1}(x)
 |               + \frac{t_{i+k+1} - x}{t_{i+k+1} - t_{i+1}} B_{i+1, k-1}(x)
 |  
 |  **Implementation details**
 |  
 |  - At least ``k+1`` coefficients are required for a spline of degree `k`,
 |    so that ``n >= k+1``. Additional coefficients, ``c[j]`` with
 |    ``j > n``, are ignored.
 |  
 |  - B-spline basis elements of degree `k` form a partition of unity on the
 |    *base interval*, ``t[k] <= x <= t[n]``.
 |  
 |  
 |  Examples
 |  --------
 |  
 |  Translating the recursive definition of B-splines into Python code, we have:
 |  
 |  >>> def B(x, k, i, t):
 |  ...    if k == 0:
 |  ...       return 1.0 if t[i] <= x < t[i+1] else 0.0
 |  ...    if t[i+k] == t[i]:
 |  ...       c1 = 0.0
 |  ...    else:
 |  ...       c1 = (x - t[i])/(t[i+k] - t[i]) * B(x, k-1, i, t)
 |  ...    if t[i+k+1] == t[i+1]:
 |  ...       c2 = 0.0
 |  ...    else:
 |  ...       c2 = (t[i+k+1] - x)/(t[i+k+1] - t[i+1]) * B(x, k-1, i+1, t)
 |  ...    return c1 + c2
 |  
 |  >>> def bspline(x, t, c, k):
 |  ...    n = len(t) - k - 1
 |  ...    assert (n >= k+1) and (len(c) >= n)
 |  ...    return sum(c[i] * B(x, k, i, t) for i in range(n))
 |  
 |  Note that this is an inefficient (if straightforward) way to
 |  evaluate B-splines --- this spline class does it in an equivalent,
 |  but much more efficient way.
 |  
 |  Here we construct a quadratic spline function on the base interval
 |  ``2 <= x <= 4`` and compare with the naive way of evaluating the spline:
 |  
 |  >>> from scipy.interpolate import BSpline
 |  >>> k = 2
 |  >>> t = [0, 1, 2, 3, 4, 5, 6]
 |  >>> c = [-1, 2, 0, -1]
 |  >>> spl = BSpline(t, c, k)
 |  >>> spl(2.5)
 |  array(1.375)
 |  >>> bspline(2.5, t, c, k)
 |  1.375
 |  
 |  Note that outside of the base interval results differ. This is because
 |  `BSpline` extrapolates the first and last polynomial pieces of b-spline
 |  functions active on the base interval.
 |  
 |  >>> import matplotlib.pyplot as plt
 |  >>> fig, ax = plt.subplots()
 |  >>> xx = np.linspace(1.5, 4.5, 50)
 |  >>> ax.plot(xx, [bspline(x, t, c ,k) for x in xx], 'r-', lw=3, label='naive')
 |  >>> ax.plot(xx, spl(xx), 'b-', lw=4, alpha=0.7, label='BSpline')
 |  >>> ax.grid(True)
 |  >>> ax.legend(loc='best')
 |  >>> plt.show()
 |  
 |  
 |  References
 |  ----------
 |  .. [1] Tom Lyche and Knut Morken, Spline methods,
 |      http://www.uio.no/studier/emner/matnat/ifi/INF-MAT5340/v05/undervisningsmateriale/
 |  .. [2] Carl de Boor, A practical guide to splines, Springer, 2001.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, x, nu=0, extrapolate=None)
 |      Evaluate a spline function.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          points to evaluate the spline at.
 |      nu: int, optional
 |          derivative to evaluate (default is 0).
 |      extrapolate : bool or 'periodic', optional
 |          whether to extrapolate based on the first and last intervals
 |          or return nans. If 'periodic', periodic extrapolation is used.
 |          Default is `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Shape is determined by replacing the interpolation axis
 |          in the coefficient array with the shape of `x`.
 |  
 |  __init__(self, t, c, k, extrapolate=True, axis=0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  antiderivative(self, nu=1)
 |      Return a b-spline representing the antiderivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Antiderivative order. Default is 1.
 |      
 |      Returns
 |      -------
 |      b : BSpline object
 |          A new instance representing the antiderivative.
 |      
 |      Notes
 |      -----
 |      If antiderivative is computed and ``self.extrapolate='periodic'``,
 |      it will be set to False for the returned instance. This is done because
 |      the antiderivative is no longer periodic and its correct evaluation
 |      outside of the initially given x interval is difficult.
 |      
 |      See Also
 |      --------
 |      splder, splantider
 |  
 |  derivative(self, nu=1)
 |      Return a b-spline representing the derivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Derivative order.
 |          Default is 1.
 |      
 |      Returns
 |      -------
 |      b : BSpline object
 |          A new instance representing the derivative.
 |      
 |      See Also
 |      --------
 |      splder, splantider
 |  
 |  integrate(self, a, b, extrapolate=None)
 |      Compute a definite integral of the spline.
 |      
 |      Parameters
 |      ----------
 |      a : float
 |          Lower limit of integration.
 |      b : float
 |          Upper limit of integration.
 |      extrapolate : bool or 'periodic', optional
 |          whether to extrapolate beyond the base interval,
 |          ``t[k] .. t[-k-1]``, or take the spline to be zero outside of the
 |          base interval. If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      I : array_like
 |          Definite integral of the spline over the interval ``[a, b]``.
 |      
 |      Examples
 |      --------
 |      Construct the linear spline ``x if x < 1 else 2 - x`` on the base
 |      interval :math:`[0, 2]`, and integrate it
 |      
 |      >>> from scipy.interpolate import BSpline
 |      >>> b = BSpline.basis_element([0, 1, 2])
 |      >>> b.integrate(0, 1)
 |      array(0.5)
 |      
 |      If the integration limits are outside of the base interval, the result
 |      is controlled by the `extrapolate` parameter
 |      
 |      >>> b.integrate(-1, 1)
 |      array(0.0)
 |      >>> b.integrate(-1, 1, extrapolate=False)
 |      array(0.5)
 |      
 |      >>> import matplotlib.pyplot as plt
 |      >>> fig, ax = plt.subplots()
 |      >>> ax.grid(True)
 |      >>> ax.axvline(0, c='r', lw=5, alpha=0.5)  # base interval
 |      >>> ax.axvline(2, c='r', lw=5, alpha=0.5)
 |      >>> xx = [-1, 1, 2]
 |      >>> ax.plot(xx, b(xx))
 |      >>> plt.show()
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  basis_element(t, extrapolate=True) from builtins.type
 |      Return a B-spline basis element ``B(x | t[0], ..., t[k+1])``.
 |      
 |      Parameters
 |      ----------
 |      t : ndarray, shape (k+1,)
 |          internal knots
 |      extrapolate : bool or 'periodic', optional
 |          whether to extrapolate beyond the base interval, ``t[0] .. t[k+1]``,
 |          or to return nans.
 |          If 'periodic', periodic extrapolation is used.
 |          Default is True.
 |      
 |      Returns
 |      -------
 |      basis_element : callable
 |          A callable representing a B-spline basis element for the knot
 |          vector `t`.
 |      
 |      Notes
 |      -----
 |      The order of the b-spline, `k`, is inferred from the length of `t` as
 |      ``len(t)-2``. The knot vector is constructed by appending and prepending
 |      ``k+1`` elements to internal knots `t`.
 |      
 |      Examples
 |      --------
 |      
 |      Construct a cubic b-spline:
 |      
 |      >>> from scipy.interpolate import BSpline
 |      >>> b = BSpline.basis_element([0, 1, 2, 3, 4])
 |      >>> k = b.k
 |      >>> b.t[k:-k]
 |      array([ 0.,  1.,  2.,  3.,  4.])
 |      >>> k
 |      3
 |      
 |      Construct a second order b-spline on ``[0, 1, 1, 2]``, and compare
 |      to its explicit form:
 |      
 |      >>> t = [-1, 0, 1, 1, 2]
 |      >>> b = BSpline.basis_element(t[1:])
 |      >>> def f(x):
 |      ...     return np.where(x < 1, x*x, (2. - x)**2)
 |      
 |      >>> import matplotlib.pyplot as plt
 |      >>> fig, ax = plt.subplots()
 |      >>> x = np.linspace(0, 2, 51)
 |      >>> ax.plot(x, b(x), 'g', lw=3)
 |      >>> ax.plot(x, f(x), 'r', lw=8, alpha=0.4)
 |      >>> ax.grid(True)
 |      >>> plt.show()
 |  
 |  construct_fast(t, c, k, extrapolate=True, axis=0) from builtins.type
 |      Construct a spline without making checks.
 |      
 |      Accepts same parameters as the regular constructor. Input arrays
 |      `t` and `c` must of correct shape and dtype.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  tck
 |      Equivalent to ``(self.t, self.c, self.k)`` (read-only).
",class,"('(self, t, c, k, extrapolate=True, axis=0)',)",scipy,1.1.0,scipy.interpolate.fitpack.BSpline,interpolate.fitpack,BSpline,"Python Library Documentation: class BSpline in module scipy.interpolate._bsplines

class BSpline(builtins.object)
 |  Univariate spline in the B-spline basis.
 |  
 |  .. math::
 |  
 |      S(x) = \sum_{j=0}^{n-1} c_j  B_{j, k; t}(x)
 |  
 |  where :math:`B_{j, k; t}` are B-spline basis functions of degree `k`
 |  and knots `t`.
 |  
 |  Parameters
 |  ----------
 |  t : ndarray, shape (n+k+1,)
 |      knots
 |  c : ndarray, shape (>=n, ...)
 |      spline coefficients
 |  k : int
 |      B-spline order
 |  extrapolate : bool or 'periodic', optional
 |      whether to extrapolate beyond the base interval, ``t[k] .. t[n]``,
 |      or to return nans.
 |      If True, extrapolates the first and last polynomial pieces of b-spline
 |      functions active on the base interval.
 |      If 'periodic', periodic extrapolation is used.
 |      Default is True.
 |  axis : int, optional
 |      Interpolation axis. Default is zero.
 |  
 |  Attributes
 |  ----------
 |  t : ndarray
 |      knot vector
 |  c : ndarray
 |      spline coefficients
 |  k : int
 |      spline degree
 |  extrapolate : bool
 |      If True, extrapolates the first and last polynomial pieces of b-spline
 |      functions active on the base interval.
 |  axis : int
 |      Interpolation axis.
 |  tck : tuple
 |      A read-only equivalent of ``(self.t, self.c, self.k)``
 |  
 |  Methods
 |  -------
 |  __call__
 |  basis_element
 |  derivative
 |  antiderivative
 |  integrate
 |  construct_fast
 |  
 |  Notes
 |  -----
 |  B-spline basis elements are defined via
 |  
 |  .. math::
 |  
 |      B_{i, 0}(x) = 1, \textrm{if $t_i \le x < t_{i+1}$, otherwise $0$,}
 |  
 |      B_{i, k}(x) = \frac{x - t_i}{t_{i+k} - t_i} B_{i, k-1}(x)
 |               + \frac{t_{i+k+1} - x}{t_{i+k+1} - t_{i+1}} B_{i+1, k-1}(x)
 |  
 |  **Implementation details**
 |  
 |  - At least ``k+1`` coefficients are required for a spline of degree `k`,
 |    so that ``n >= k+1``. Additional coefficients, ``c[j]`` with
 |    ``j > n``, are ignored.
 |  
 |  - B-spline basis elements of degree `k` form a partition of unity on the
 |    *base interval*, ``t[k] <= x <= t[n]``.
 |  
 |  
 |  Examples
 |  --------
 |  
 |  Translating the recursive definition of B-splines into Python code, we have:
 |  
 |  >>> def B(x, k, i, t):
 |  ...    if k == 0:
 |  ...       return 1.0 if t[i] <= x < t[i+1] else 0.0
 |  ...    if t[i+k] == t[i]:
 |  ...       c1 = 0.0
 |  ...    else:
 |  ...       c1 = (x - t[i])/(t[i+k] - t[i]) * B(x, k-1, i, t)
 |  ...    if t[i+k+1] == t[i+1]:
 |  ...       c2 = 0.0
 |  ...    else:
 |  ...       c2 = (t[i+k+1] - x)/(t[i+k+1] - t[i+1]) * B(x, k-1, i+1, t)
 |  ...    return c1 + c2
 |  
 |  >>> def bspline(x, t, c, k):
 |  ...    n = len(t) - k - 1
 |  ...    assert (n >= k+1) and (len(c) >= n)
 |  ...    return sum(c[i] * B(x, k, i, t) for i in range(n))
 |  
 |  Note that this is an inefficient (if straightforward) way to
 |  evaluate B-splines --- this spline class does it in an equivalent,
 |  but much more efficient way.
 |  
 |  Here we construct a quadratic spline function on the base interval
 |  ``2 <= x <= 4`` and compare with the naive way of evaluating the spline:
 |  
 |  >>> from scipy.interpolate import BSpline
 |  >>> k = 2
 |  >>> t = [0, 1, 2, 3, 4, 5, 6]
 |  >>> c = [-1, 2, 0, -1]
 |  >>> spl = BSpline(t, c, k)
 |  >>> spl(2.5)
 |  array(1.375)
 |  >>> bspline(2.5, t, c, k)
 |  1.375
 |  
 |  Note that outside of the base interval results differ. This is because
 |  `BSpline` extrapolates the first and last polynomial pieces of b-spline
 |  functions active on the base interval.
 |  
 |  >>> import matplotlib.pyplot as plt
 |  >>> fig, ax = plt.subplots()
 |  >>> xx = np.linspace(1.5, 4.5, 50)
 |  >>> ax.plot(xx, [bspline(x, t, c ,k) for x in xx], 'r-', lw=3, label='naive')
 |  >>> ax.plot(xx, spl(xx), 'b-', lw=4, alpha=0.7, label='BSpline')
 |  >>> ax.grid(True)
 |  >>> ax.legend(loc='best')
 |  >>> plt.show()
 |  
 |  
 |  References
 |  ----------
 |  .. [1] Tom Lyche and Knut Morken, Spline methods,
 |      http://www.uio.no/studier/emner/matnat/ifi/INF-MAT5340/v05/undervisningsmateriale/
 |  .. [2] Carl de Boor, A practical guide to splines, Springer, 2001.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, x, nu=0, extrapolate=None)
 |      Evaluate a spline function.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          points to evaluate the spline at.
 |      nu: int, optional
 |          derivative to evaluate (default is 0).
 |      extrapolate : bool or 'periodic', optional
 |          whether to extrapolate based on the first and last intervals
 |          or return nans. If 'periodic', periodic extrapolation is used.
 |          Default is `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Shape is determined by replacing the interpolation axis
 |          in the coefficient array with the shape of `x`.
 |  
 |  __init__(self, t, c, k, extrapolate=True, axis=0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  antiderivative(self, nu=1)
 |      Return a b-spline representing the antiderivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Antiderivative order. Default is 1.
 |      
 |      Returns
 |      -------
 |      b : BSpline object
 |          A new instance representing the antiderivative.
 |      
 |      Notes
 |      -----
 |      If antiderivative is computed and ``self.extrapolate='periodic'``,
 |      it will be set to False for the returned instance. This is done because
 |      the antiderivative is no longer periodic and its correct evaluation
 |      outside of the initially given x interval is difficult.
 |      
 |      See Also
 |      --------
 |      splder, splantider
 |  
 |  derivative(self, nu=1)
 |      Return a b-spline representing the derivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Derivative order.
 |          Default is 1.
 |      
 |      Returns
 |      -------
 |      b : BSpline object
 |          A new instance representing the derivative.
 |      
 |      See Also
 |      --------
 |      splder, splantider
 |  
 |  integrate(self, a, b, extrapolate=None)
 |      Compute a definite integral of the spline.
 |      
 |      Parameters
 |      ----------
 |      a : float
 |          Lower limit of integration.
 |      b : float
 |          Upper limit of integration.
 |      extrapolate : bool or 'periodic', optional
 |          whether to extrapolate beyond the base interval,
 |          ``t[k] .. t[-k-1]``, or take the spline to be zero outside of the
 |          base interval. If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      I : array_like
 |          Definite integral of the spline over the interval ``[a, b]``.
 |      
 |      Examples
 |      --------
 |      Construct the linear spline ``x if x < 1 else 2 - x`` on the base
 |      interval :math:`[0, 2]`, and integrate it
 |      
 |      >>> from scipy.interpolate import BSpline
 |      >>> b = BSpline.basis_element([0, 1, 2])
 |      >>> b.integrate(0, 1)
 |      array(0.5)
 |      
 |      If the integration limits are outside of the base interval, the result
 |      is controlled by the `extrapolate` parameter
 |      
 |      >>> b.integrate(-1, 1)
 |      array(0.0)
 |      >>> b.integrate(-1, 1, extrapolate=False)
 |      array(0.5)
 |      
 |      >>> import matplotlib.pyplot as plt
 |      >>> fig, ax = plt.subplots()
 |      >>> ax.grid(True)
 |      >>> ax.axvline(0, c='r', lw=5, alpha=0.5)  # base interval
 |      >>> ax.axvline(2, c='r', lw=5, alpha=0.5)
 |      >>> xx = [-1, 1, 2]
 |      >>> ax.plot(xx, b(xx))
 |      >>> plt.show()
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  basis_element(t, extrapolate=True) from builtins.type
 |      Return a B-spline basis element ``B(x | t[0], ..., t[k+1])``.
 |      
 |      Parameters
 |      ----------
 |      t : ndarray, shape (k+1,)
 |          internal knots
 |      extrapolate : bool or 'periodic', optional
 |          whether to extrapolate beyond the base interval, ``t[0] .. t[k+1]``,
 |          or to return nans.
 |          If 'periodic', periodic extrapolation is used.
 |          Default is True.
 |      
 |      Returns
 |      -------
 |      basis_element : callable
 |          A callable representing a B-spline basis element for the knot
 |          vector `t`.
 |      
 |      Notes
 |      -----
 |      The order of the b-spline, `k`, is inferred from the length of `t` as
 |      ``len(t)-2``. The knot vector is constructed by appending and prepending
 |      ``k+1`` elements to internal knots `t`.
 |      
 |      Examples
 |      --------
 |      
 |      Construct a cubic b-spline:
 |      
 |      >>> from scipy.interpolate import BSpline
 |      >>> b = BSpline.basis_element([0, 1, 2, 3, 4])
 |      >>> k = b.k
 |      >>> b.t[k:-k]
 |      array([ 0.,  1.,  2.,  3.,  4.])
 |      >>> k
 |      3
 |      
 |      Construct a second order b-spline on ``[0, 1, 1, 2]``, and compare
 |      to its explicit form:
 |      
 |      >>> t = [-1, 0, 1, 1, 2]
 |      >>> b = BSpline.basis_element(t[1:])
 |      >>> def f(x):
 |      ...     return np.where(x < 1, x*x, (2. - x)**2)
 |      
 |      >>> import matplotlib.pyplot as plt
 |      >>> fig, ax = plt.subplots()
 |      >>> x = np.linspace(0, 2, 51)
 |      >>> ax.plot(x, b(x), 'g', lw=3)
 |      >>> ax.plot(x, f(x), 'r', lw=8, alpha=0.4)
 |      >>> ax.grid(True)
 |      >>> plt.show()
 |  
 |  construct_fast(t, c, k, extrapolate=True, axis=0) from builtins.type
 |      Construct a spline without making checks.
 |      
 |      Accepts same parameters as the regular constructor. Input arrays
 |      `t` and `c` must of correct shape and dtype.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  tck
 |      Equivalent to ``(self.t, self.c, self.k)`` (read-only).
",class,"('self', 't', 'c', 'k', 'extrapolate', 'axis')","(nan, nan, nan, nan, True, 0)","(nan, nan, nan, nan, 'bool', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, t, c, k, extrapolate=True, axis=0)',)"
scipy,1.1.0,scipy.interpolate.fitpack.BSpline.basis_element,interpolate.fitpack.BSpline,basis_element,"Python Library Documentation: method basis_element in module scipy.interpolate._bsplines

basis_element(t, extrapolate=True) method of builtins.type instance
    Return a B-spline basis element ``B(x | t[0], ..., t[k+1])``.
    
    Parameters
    ----------
    t : ndarray, shape (k+1,)
        internal knots
    extrapolate : bool or 'periodic', optional
        whether to extrapolate beyond the base interval, ``t[0] .. t[k+1]``,
        or to return nans.
        If 'periodic', periodic extrapolation is used.
        Default is True.
    
    Returns
    -------
    basis_element : callable
        A callable representing a B-spline basis element for the knot
        vector `t`.
    
    Notes
    -----
    The order of the b-spline, `k`, is inferred from the length of `t` as
    ``len(t)-2``. The knot vector is constructed by appending and prepending
    ``k+1`` elements to internal knots `t`.
    
    Examples
    --------
    
    Construct a cubic b-spline:
    
    >>> from scipy.interpolate import BSpline
    >>> b = BSpline.basis_element([0, 1, 2, 3, 4])
    >>> k = b.k
    >>> b.t[k:-k]
    array([ 0.,  1.,  2.,  3.,  4.])
    >>> k
    3
    
    Construct a second order b-spline on ``[0, 1, 1, 2]``, and compare
    to its explicit form:
    
    >>> t = [-1, 0, 1, 1, 2]
    >>> b = BSpline.basis_element(t[1:])
    >>> def f(x):
    ...     return np.where(x < 1, x*x, (2. - x)**2)
    
    >>> import matplotlib.pyplot as plt
    >>> fig, ax = plt.subplots()
    >>> x = np.linspace(0, 2, 51)
    >>> ax.plot(x, b(x), 'g', lw=3)
    >>> ax.plot(x, f(x), 'r', lw=8, alpha=0.4)
    >>> ax.grid(True)
    >>> plt.show()
",method,"('(t, extrapolate=True)',)",scipy,1.1.0,scipy.interpolate.fitpack.BSpline.basis_element,interpolate.fitpack.BSpline,basis_element,"Python Library Documentation: method basis_element in module scipy.interpolate._bsplines

basis_element(t, extrapolate=True) method of builtins.type instance
    Return a B-spline basis element ``B(x | t[0], ..., t[k+1])``.
    
    Parameters
    ----------
    t : ndarray, shape (k+1,)
        internal knots
    extrapolate : bool or 'periodic', optional
        whether to extrapolate beyond the base interval, ``t[0] .. t[k+1]``,
        or to return nans.
        If 'periodic', periodic extrapolation is used.
        Default is True.
    
    Returns
    -------
    basis_element : callable
        A callable representing a B-spline basis element for the knot
        vector `t`.
    
    Notes
    -----
    The order of the b-spline, `k`, is inferred from the length of `t` as
    ``len(t)-2``. The knot vector is constructed by appending and prepending
    ``k+1`` elements to internal knots `t`.
    
    Examples
    --------
    
    Construct a cubic b-spline:
    
    >>> from scipy.interpolate import BSpline
    >>> b = BSpline.basis_element([0, 1, 2, 3, 4])
    >>> k = b.k
    >>> b.t[k:-k]
    array([ 0.,  1.,  2.,  3.,  4.])
    >>> k
    3
    
    Construct a second order b-spline on ``[0, 1, 1, 2]``, and compare
    to its explicit form:
    
    >>> t = [-1, 0, 1, 1, 2]
    >>> b = BSpline.basis_element(t[1:])
    >>> def f(x):
    ...     return np.where(x < 1, x*x, (2. - x)**2)
    
    >>> import matplotlib.pyplot as plt
    >>> fig, ax = plt.subplots()
    >>> x = np.linspace(0, 2, 51)
    >>> ax.plot(x, b(x), 'g', lw=3)
    >>> ax.plot(x, f(x), 'r', lw=8, alpha=0.4)
    >>> ax.grid(True)
    >>> plt.show()
",method,"('cls', 't', 'extrapolate')","(nan, nan, True)","(nan, nan, 'bool')","('arg_info', 'arg_info', 'arg_info')","('(t, extrapolate=True)',)"
scipy,1.1.0,scipy.interpolate.fitpack.BSpline.construct_fast,interpolate.fitpack.BSpline,construct_fast,"Python Library Documentation: method construct_fast in module scipy.interpolate._bsplines

construct_fast(t, c, k, extrapolate=True, axis=0) method of builtins.type instance
    Construct a spline without making checks.
    
    Accepts same parameters as the regular constructor. Input arrays
    `t` and `c` must of correct shape and dtype.
",method,"('(t, c, k, extrapolate=True, axis=0)',)",scipy,1.1.0,scipy.interpolate.fitpack.BSpline.construct_fast,interpolate.fitpack.BSpline,construct_fast,"Python Library Documentation: method construct_fast in module scipy.interpolate._bsplines

construct_fast(t, c, k, extrapolate=True, axis=0) method of builtins.type instance
    Construct a spline without making checks.
    
    Accepts same parameters as the regular constructor. Input arrays
    `t` and `c` must of correct shape and dtype.
",method,"('cls', 't', 'c', 'k', 'extrapolate', 'axis')","(nan, nan, nan, nan, True, 0)","(nan, nan, nan, nan, 'bool', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(t, c, k, extrapolate=True, axis=0)',)"
scipy,1.1.0,scipy.interpolate.fitpack.bisplev,interpolate.fitpack,bisplev,"Python Library Documentation: function bisplev in module scipy.interpolate._fitpack_impl

bisplev(x, y, tck, dx=0, dy=0)
    Evaluate a bivariate B-spline and its derivatives.
    
    Return a rank-2 array of spline function values (or spline derivative
    values) at points given by the cross-product of the rank-1 arrays `x` and
    `y`.  In special cases, return an array or just a float if either `x` or
    `y` or both are floats.  Based on BISPEV from FITPACK.
    
    Parameters
    ----------
    x, y : ndarray
        Rank-1 arrays specifying the domain over which to evaluate the
        spline or its derivative.
    tck : tuple
        A sequence of length 5 returned by `bisplrep` containing the knot
        locations, the coefficients, and the degree of the spline:
        [tx, ty, c, kx, ky].
    dx, dy : int, optional
        The orders of the partial derivatives in `x` and `y` respectively.
    
    Returns
    -------
    vals : ndarray
        The B-spline or its derivative evaluated over the set formed by
        the cross-product of `x` and `y`.
    
    See Also
    --------
    splprep, splrep, splint, sproot, splev
    UnivariateSpline, BivariateSpline
    
    Notes
    -----
        See `bisplrep` to generate the `tck` representation.
    
    References
    ----------
    .. [1] Dierckx P. : An algorithm for surface fitting
       with spline functions
       Ima J. Numer. Anal. 1 (1981) 267-283.
    .. [2] Dierckx P. : An algorithm for surface fitting
       with spline functions
       report tw50, Dept. Computer Science,K.U.Leuven, 1980.
    .. [3] Dierckx P. : Curve and surface fitting with splines,
       Monographs on Numerical Analysis, Oxford University Press, 1993.
",function,"('(x, y, tck, dx=0, dy=0)',)",scipy,1.1.0,scipy.interpolate.fitpack.bisplev,interpolate.fitpack,bisplev,"Python Library Documentation: function bisplev in module scipy.interpolate._fitpack_impl

bisplev(x, y, tck, dx=0, dy=0)
    Evaluate a bivariate B-spline and its derivatives.
    
    Return a rank-2 array of spline function values (or spline derivative
    values) at points given by the cross-product of the rank-1 arrays `x` and
    `y`.  In special cases, return an array or just a float if either `x` or
    `y` or both are floats.  Based on BISPEV from FITPACK.
    
    Parameters
    ----------
    x, y : ndarray
        Rank-1 arrays specifying the domain over which to evaluate the
        spline or its derivative.
    tck : tuple
        A sequence of length 5 returned by `bisplrep` containing the knot
        locations, the coefficients, and the degree of the spline:
        [tx, ty, c, kx, ky].
    dx, dy : int, optional
        The orders of the partial derivatives in `x` and `y` respectively.
    
    Returns
    -------
    vals : ndarray
        The B-spline or its derivative evaluated over the set formed by
        the cross-product of `x` and `y`.
    
    See Also
    --------
    splprep, splrep, splint, sproot, splev
    UnivariateSpline, BivariateSpline
    
    Notes
    -----
        See `bisplrep` to generate the `tck` representation.
    
    References
    ----------
    .. [1] Dierckx P. : An algorithm for surface fitting
       with spline functions
       Ima J. Numer. Anal. 1 (1981) 267-283.
    .. [2] Dierckx P. : An algorithm for surface fitting
       with spline functions
       report tw50, Dept. Computer Science,K.U.Leuven, 1980.
    .. [3] Dierckx P. : Curve and surface fitting with splines,
       Monographs on Numerical Analysis, Oxford University Press, 1993.
",function,"('x', 'y', 'tck', 'dx', 'dy')","(nan, nan, nan, 0, 0)","(nan, nan, nan, 'int', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, y, tck, dx=0, dy=0)',)"
scipy,1.1.0,scipy.interpolate.fitpack.bisplrep,interpolate.fitpack,bisplrep,"Python Library Documentation: function bisplrep in module scipy.interpolate._fitpack_impl

bisplrep(x, y, z, w=None, xb=None, xe=None, yb=None, ye=None, kx=3, ky=3, task=0, s=None, eps=1e-16, tx=None, ty=None, full_output=0, nxest=None, nyest=None, quiet=1)
    Find a bivariate B-spline representation of a surface.
    
    Given a set of data points (x[i], y[i], z[i]) representing a surface
    z=f(x,y), compute a B-spline representation of the surface. Based on
    the routine SURFIT from FITPACK.
    
    Parameters
    ----------
    x, y, z : ndarray
        Rank-1 arrays of data points.
    w : ndarray, optional
        Rank-1 array of weights. By default ``w=np.ones(len(x))``.
    xb, xe : float, optional
        End points of approximation interval in `x`.
        By default ``xb = x.min(), xe=x.max()``.
    yb, ye : float, optional
        End points of approximation interval in `y`.
        By default ``yb=y.min(), ye = y.max()``.
    kx, ky : int, optional
        The degrees of the spline (1 <= kx, ky <= 5).
        Third order (kx=ky=3) is recommended.
    task : int, optional
        If task=0, find knots in x and y and coefficients for a given
        smoothing factor, s.
        If task=1, find knots and coefficients for another value of the
        smoothing factor, s.  bisplrep must have been previously called
        with task=0 or task=1.
        If task=-1, find coefficients for a given set of knots tx, ty.
    s : float, optional
        A non-negative smoothing factor.  If weights correspond
        to the inverse of the standard-deviation of the errors in z,
        then a good s-value should be found in the range
        ``(m-sqrt(2*m),m+sqrt(2*m))`` where m=len(x).
    eps : float, optional
        A threshold for determining the effective rank of an
        over-determined linear system of equations (0 < eps < 1).
        `eps` is not likely to need changing.
    tx, ty : ndarray, optional
        Rank-1 arrays of the knots of the spline for task=-1
    full_output : int, optional
        Non-zero to return optional outputs.
    nxest, nyest : int, optional
        Over-estimates of the total number of knots. If None then
        ``nxest = max(kx+sqrt(m/2),2*kx+3)``,
        ``nyest = max(ky+sqrt(m/2),2*ky+3)``.
    quiet : int, optional
        Non-zero to suppress printing of messages.
        This parameter is deprecated; use standard Python warning filters
        instead.
    
    Returns
    -------
    tck : array_like
        A list [tx, ty, c, kx, ky] containing the knots (tx, ty) and
        coefficients (c) of the bivariate B-spline representation of the
        surface along with the degree of the spline.
    fp : ndarray
        The weighted sum of squared residuals of the spline approximation.
    ier : int
        An integer flag about splrep success.  Success is indicated if
        ier<=0. If ier in [1,2,3] an error occurred but was not raised.
        Otherwise an error is raised.
    msg : str
        A message corresponding to the integer flag, ier.
    
    See Also
    --------
    splprep, splrep, splint, sproot, splev
    UnivariateSpline, BivariateSpline
    
    Notes
    -----
    See `bisplev` to evaluate the value of the B-spline given its tck
    representation.
    
    References
    ----------
    .. [1] Dierckx P.:An algorithm for surface fitting with spline functions
       Ima J. Numer. Anal. 1 (1981) 267-283.
    .. [2] Dierckx P.:An algorithm for surface fitting with spline functions
       report tw50, Dept. Computer Science,K.U.Leuven, 1980.
    .. [3] Dierckx P.:Curve and surface fitting with splines, Monographs on
       Numerical Analysis, Oxford University Press, 1993.
",function,"('(x, y, z, w=None, xb=None, xe=None, yb=None, ye=None, kx=3, ky=3, task=0, s=None, eps=1e-16, tx=None, ty=None, full_output=0, nxest=None, nyest=None, quiet=1)',)",scipy,1.1.0,scipy.interpolate.fitpack.bisplrep,interpolate.fitpack,bisplrep,"Python Library Documentation: function bisplrep in module scipy.interpolate._fitpack_impl

bisplrep(x, y, z, w=None, xb=None, xe=None, yb=None, ye=None, kx=3, ky=3, task=0, s=None, eps=1e-16, tx=None, ty=None, full_output=0, nxest=None, nyest=None, quiet=1)
    Find a bivariate B-spline representation of a surface.
    
    Given a set of data points (x[i], y[i], z[i]) representing a surface
    z=f(x,y), compute a B-spline representation of the surface. Based on
    the routine SURFIT from FITPACK.
    
    Parameters
    ----------
    x, y, z : ndarray
        Rank-1 arrays of data points.
    w : ndarray, optional
        Rank-1 array of weights. By default ``w=np.ones(len(x))``.
    xb, xe : float, optional
        End points of approximation interval in `x`.
        By default ``xb = x.min(), xe=x.max()``.
    yb, ye : float, optional
        End points of approximation interval in `y`.
        By default ``yb=y.min(), ye = y.max()``.
    kx, ky : int, optional
        The degrees of the spline (1 <= kx, ky <= 5).
        Third order (kx=ky=3) is recommended.
    task : int, optional
        If task=0, find knots in x and y and coefficients for a given
        smoothing factor, s.
        If task=1, find knots and coefficients for another value of the
        smoothing factor, s.  bisplrep must have been previously called
        with task=0 or task=1.
        If task=-1, find coefficients for a given set of knots tx, ty.
    s : float, optional
        A non-negative smoothing factor.  If weights correspond
        to the inverse of the standard-deviation of the errors in z,
        then a good s-value should be found in the range
        ``(m-sqrt(2*m),m+sqrt(2*m))`` where m=len(x).
    eps : float, optional
        A threshold for determining the effective rank of an
        over-determined linear system of equations (0 < eps < 1).
        `eps` is not likely to need changing.
    tx, ty : ndarray, optional
        Rank-1 arrays of the knots of the spline for task=-1
    full_output : int, optional
        Non-zero to return optional outputs.
    nxest, nyest : int, optional
        Over-estimates of the total number of knots. If None then
        ``nxest = max(kx+sqrt(m/2),2*kx+3)``,
        ``nyest = max(ky+sqrt(m/2),2*ky+3)``.
    quiet : int, optional
        Non-zero to suppress printing of messages.
        This parameter is deprecated; use standard Python warning filters
        instead.
    
    Returns
    -------
    tck : array_like
        A list [tx, ty, c, kx, ky] containing the knots (tx, ty) and
        coefficients (c) of the bivariate B-spline representation of the
        surface along with the degree of the spline.
    fp : ndarray
        The weighted sum of squared residuals of the spline approximation.
    ier : int
        An integer flag about splrep success.  Success is indicated if
        ier<=0. If ier in [1,2,3] an error occurred but was not raised.
        Otherwise an error is raised.
    msg : str
        A message corresponding to the integer flag, ier.
    
    See Also
    --------
    splprep, splrep, splint, sproot, splev
    UnivariateSpline, BivariateSpline
    
    Notes
    -----
    See `bisplev` to evaluate the value of the B-spline given its tck
    representation.
    
    References
    ----------
    .. [1] Dierckx P.:An algorithm for surface fitting with spline functions
       Ima J. Numer. Anal. 1 (1981) 267-283.
    .. [2] Dierckx P.:An algorithm for surface fitting with spline functions
       report tw50, Dept. Computer Science,K.U.Leuven, 1980.
    .. [3] Dierckx P.:Curve and surface fitting with splines, Monographs on
       Numerical Analysis, Oxford University Press, 1993.
",function,"('x', 'y', 'z', 'w', 'xb', 'xe', 'yb', 'ye', 'kx', 'ky', 'task', 's', 'eps', 'tx', 'ty', 'full_output', 'nxest', 'nyest', 'quiet')","(nan, nan, nan, None, None, None, None, None, 3, 3, 0, None, 1e-16, None, None, 0, None, None, 1)","(nan, nan, nan, 'NoneType', 'NoneType', 'NoneType', 'NoneType', 'NoneType', 'int', 'int', 'int', 'NoneType', 'float', 'NoneType', 'NoneType', 'int', 'NoneType', 'NoneType', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, y, z, w=None, xb=None, xe=None, yb=None, ye=None, kx=3, ky=3, task=0, s=None, eps=1e-16, tx=None, ty=None, full_output=0, nxest=None, nyest=None, quiet=1)',)"
scipy,1.1.0,scipy.interpolate.fitpack.dblint,interpolate.fitpack,dblint,"Python Library Documentation: function dblint in module scipy.interpolate._fitpack_impl

dblint(xa, xb, ya, yb, tck)
    Evaluate the integral of a spline over area [xa,xb] x [ya,yb].
    
    Parameters
    ----------
    xa, xb : float
        The end-points of the x integration interval.
    ya, yb : float
        The end-points of the y integration interval.
    tck : list [tx, ty, c, kx, ky]
        A sequence of length 5 returned by bisplrep containing the knot
        locations tx, ty, the coefficients c, and the degrees kx, ky
        of the spline.
    
    Returns
    -------
    integ : float
        The value of the resulting integral.
",function,"('(xa, xb, ya, yb, tck)',)",scipy,1.1.0,scipy.interpolate.fitpack.dblint,interpolate.fitpack,dblint,"Python Library Documentation: function dblint in module scipy.interpolate._fitpack_impl

dblint(xa, xb, ya, yb, tck)
    Evaluate the integral of a spline over area [xa,xb] x [ya,yb].
    
    Parameters
    ----------
    xa, xb : float
        The end-points of the x integration interval.
    ya, yb : float
        The end-points of the y integration interval.
    tck : list [tx, ty, c, kx, ky]
        A sequence of length 5 returned by bisplrep containing the knot
        locations tx, ty, the coefficients c, and the degrees kx, ky
        of the spline.
    
    Returns
    -------
    integ : float
        The value of the resulting integral.
",function,"('xa', 'xb', 'ya', 'yb', 'tck')","(nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(xa, xb, ya, yb, tck)',)"
scipy,1.1.0,scipy.interpolate.fitpack.insert,interpolate.fitpack,insert,"Python Library Documentation: function insert in module scipy.interpolate.fitpack

insert(x, tck, m=1, per=0)
    Insert knots into a B-spline.
    
    Given the knots and coefficients of a B-spline representation, create a
    new B-spline with a knot inserted `m` times at point `x`.
    This is a wrapper around the FORTRAN routine insert of FITPACK.
    
    Parameters
    ----------
    x (u) : array_like
        A 1-D point at which to insert a new knot(s).  If `tck` was returned
        from ``splprep``, then the parameter values, u should be given.
    tck : a `BSpline` instance or a tuple
        If tuple, then it is expected to be a tuple (t,c,k) containing
        the vector of knots, the B-spline coefficients, and the degree of
        the spline.
    m : int, optional
        The number of times to insert the given knot (its multiplicity).
        Default is 1.
    per : int, optional
        If non-zero, the input spline is considered periodic.
    
    Returns
    -------
    BSpline instance or a tuple
        A new B-spline with knots t, coefficients c, and degree k.
        ``t(k+1) <= x <= t(n-k)``, where k is the degree of the spline.
        In case of a periodic spline (``per != 0``) there must be
        either at least k interior knots t(j) satisfying ``t(k+1)<t(j)<=x``
        or at least k interior knots t(j) satisfying ``x<=t(j)<t(n-k)``.
        A tuple is returned iff the input argument `tck` is a tuple, otherwise
        a BSpline object is constructed and returned.
    
    Notes
    -----
    Based on algorithms from [1]_ and [2]_.
    
    Manipulating the tck-tuples directly is not recommended. In new code,
    prefer using the `BSpline` objects.
    
    References
    ----------
    .. [1] W. Boehm, ""Inserting new knots into b-spline curves."",
        Computer Aided Design, 12, p.199-201, 1980.
    .. [2] P. Dierckx, ""Curve and surface fitting with splines, Monographs on
        Numerical Analysis"", Oxford University Press, 1993.
",function,"('(x, tck, m=1, per=0)',)",scipy,1.1.0,scipy.interpolate.fitpack.insert,interpolate.fitpack,insert,"Python Library Documentation: function insert in module scipy.interpolate.fitpack

insert(x, tck, m=1, per=0)
    Insert knots into a B-spline.
    
    Given the knots and coefficients of a B-spline representation, create a
    new B-spline with a knot inserted `m` times at point `x`.
    This is a wrapper around the FORTRAN routine insert of FITPACK.
    
    Parameters
    ----------
    x (u) : array_like
        A 1-D point at which to insert a new knot(s).  If `tck` was returned
        from ``splprep``, then the parameter values, u should be given.
    tck : a `BSpline` instance or a tuple
        If tuple, then it is expected to be a tuple (t,c,k) containing
        the vector of knots, the B-spline coefficients, and the degree of
        the spline.
    m : int, optional
        The number of times to insert the given knot (its multiplicity).
        Default is 1.
    per : int, optional
        If non-zero, the input spline is considered periodic.
    
    Returns
    -------
    BSpline instance or a tuple
        A new B-spline with knots t, coefficients c, and degree k.
        ``t(k+1) <= x <= t(n-k)``, where k is the degree of the spline.
        In case of a periodic spline (``per != 0``) there must be
        either at least k interior knots t(j) satisfying ``t(k+1)<t(j)<=x``
        or at least k interior knots t(j) satisfying ``x<=t(j)<t(n-k)``.
        A tuple is returned iff the input argument `tck` is a tuple, otherwise
        a BSpline object is constructed and returned.
    
    Notes
    -----
    Based on algorithms from [1]_ and [2]_.
    
    Manipulating the tck-tuples directly is not recommended. In new code,
    prefer using the `BSpline` objects.
    
    References
    ----------
    .. [1] W. Boehm, ""Inserting new knots into b-spline curves."",
        Computer Aided Design, 12, p.199-201, 1980.
    .. [2] P. Dierckx, ""Curve and surface fitting with splines, Monographs on
        Numerical Analysis"", Oxford University Press, 1993.
",function,"('x', 'tck', 'm', 'per')","(nan, nan, 1, 0)","(nan, nan, 'int', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, tck, m=1, per=0)',)"
scipy,1.1.0,scipy.interpolate.fitpack.spalde,interpolate.fitpack,spalde,"Python Library Documentation: function spalde in module scipy.interpolate.fitpack

spalde(x, tck)
    Evaluate all derivatives of a B-spline.
    
    Given the knots and coefficients of a cubic B-spline compute all
    derivatives up to order k at a point (or set of points).
    
    Parameters
    ----------
    x : array_like
        A point or a set of points at which to evaluate the derivatives.
        Note that ``t(k) <= x <= t(n-k+1)`` must hold for each `x`.
    tck : tuple
        A tuple ``(t, c, k)``, containing the vector of knots, the B-spline
        coefficients, and the degree of the spline (see `splev`).
    
    Returns
    -------
    results : {ndarray, list of ndarrays}
        An array (or a list of arrays) containing all derivatives
        up to order k inclusive for each point `x`.
    
    See Also
    --------
    splprep, splrep, splint, sproot, splev, bisplrep, bisplev,
    BSpline
    
    References
    ----------
    .. [1] C. de Boor: On calculating with b-splines, J. Approximation Theory
       6 (1972) 50-62.
    .. [2] M. G. Cox : The numerical evaluation of b-splines, J. Inst. Maths
       applics 10 (1972) 134-149.
    .. [3] P. Dierckx : Curve and surface fitting with splines, Monographs on
       Numerical Analysis, Oxford University Press, 1993.
",function,"('(x, tck)',)",scipy,1.1.0,scipy.interpolate.fitpack.spalde,interpolate.fitpack,spalde,"Python Library Documentation: function spalde in module scipy.interpolate.fitpack

spalde(x, tck)
    Evaluate all derivatives of a B-spline.
    
    Given the knots and coefficients of a cubic B-spline compute all
    derivatives up to order k at a point (or set of points).
    
    Parameters
    ----------
    x : array_like
        A point or a set of points at which to evaluate the derivatives.
        Note that ``t(k) <= x <= t(n-k+1)`` must hold for each `x`.
    tck : tuple
        A tuple ``(t, c, k)``, containing the vector of knots, the B-spline
        coefficients, and the degree of the spline (see `splev`).
    
    Returns
    -------
    results : {ndarray, list of ndarrays}
        An array (or a list of arrays) containing all derivatives
        up to order k inclusive for each point `x`.
    
    See Also
    --------
    splprep, splrep, splint, sproot, splev, bisplrep, bisplev,
    BSpline
    
    References
    ----------
    .. [1] C. de Boor: On calculating with b-splines, J. Approximation Theory
       6 (1972) 50-62.
    .. [2] M. G. Cox : The numerical evaluation of b-splines, J. Inst. Maths
       applics 10 (1972) 134-149.
    .. [3] P. Dierckx : Curve and surface fitting with splines, Monographs on
       Numerical Analysis, Oxford University Press, 1993.
",function,"('x', 'tck')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(x, tck)',)"
scipy,1.1.0,scipy.interpolate.fitpack.splantider,interpolate.fitpack,splantider,"Python Library Documentation: function splantider in module scipy.interpolate.fitpack

splantider(tck, n=1)
    Compute the spline for the antiderivative (integral) of a given spline.
    
    Parameters
    ----------
    tck : BSpline instance or a tuple of (t, c, k)
        Spline whose antiderivative to compute
    n : int, optional
        Order of antiderivative to evaluate. Default: 1
    
    Returns
    -------
    BSpline instance or a tuple of (t2, c2, k2)
        Spline of order k2=k+n representing the antiderivative of the input
        spline.
        A tuple is returned iff the input argument `tck` is a tuple, otherwise
        a BSpline object is constructed and returned.
    
    See Also
    --------
    splder, splev, spalde
    BSpline
    
    Notes
    -----
    The `splder` function is the inverse operation of this function.
    Namely, ``splder(splantider(tck))`` is identical to `tck`, modulo
    rounding error.
    
    .. versionadded:: 0.13.0
    
    Examples
    --------
    >>> from scipy.interpolate import splrep, splder, splantider, splev
    >>> x = np.linspace(0, np.pi/2, 70)
    >>> y = 1 / np.sqrt(1 - 0.8*np.sin(x)**2)
    >>> spl = splrep(x, y)
    
    The derivative is the inverse operation of the antiderivative,
    although some floating point error accumulates:
    
    >>> splev(1.7, spl), splev(1.7, splder(splantider(spl)))
    (array(2.1565429877197317), array(2.1565429877201865))
    
    Antiderivative can be used to evaluate definite integrals:
    
    >>> ispl = splantider(spl)
    >>> splev(np.pi/2, ispl) - splev(0, ispl)
    2.2572053588768486
    
    This is indeed an approximation to the complete elliptic integral
    :math:`K(m) = \int_0^{\pi/2} [1 - m\sin^2 x]^{-1/2} dx`:
    
    >>> from scipy.special import ellipk
    >>> ellipk(0.8)
    2.2572053268208538
",function,"('(tck, n=1)',)",scipy,1.1.0,scipy.interpolate.fitpack.splantider,interpolate.fitpack,splantider,"Python Library Documentation: function splantider in module scipy.interpolate.fitpack

splantider(tck, n=1)
    Compute the spline for the antiderivative (integral) of a given spline.
    
    Parameters
    ----------
    tck : BSpline instance or a tuple of (t, c, k)
        Spline whose antiderivative to compute
    n : int, optional
        Order of antiderivative to evaluate. Default: 1
    
    Returns
    -------
    BSpline instance or a tuple of (t2, c2, k2)
        Spline of order k2=k+n representing the antiderivative of the input
        spline.
        A tuple is returned iff the input argument `tck` is a tuple, otherwise
        a BSpline object is constructed and returned.
    
    See Also
    --------
    splder, splev, spalde
    BSpline
    
    Notes
    -----
    The `splder` function is the inverse operation of this function.
    Namely, ``splder(splantider(tck))`` is identical to `tck`, modulo
    rounding error.
    
    .. versionadded:: 0.13.0
    
    Examples
    --------
    >>> from scipy.interpolate import splrep, splder, splantider, splev
    >>> x = np.linspace(0, np.pi/2, 70)
    >>> y = 1 / np.sqrt(1 - 0.8*np.sin(x)**2)
    >>> spl = splrep(x, y)
    
    The derivative is the inverse operation of the antiderivative,
    although some floating point error accumulates:
    
    >>> splev(1.7, spl), splev(1.7, splder(splantider(spl)))
    (array(2.1565429877197317), array(2.1565429877201865))
    
    Antiderivative can be used to evaluate definite integrals:
    
    >>> ispl = splantider(spl)
    >>> splev(np.pi/2, ispl) - splev(0, ispl)
    2.2572053588768486
    
    This is indeed an approximation to the complete elliptic integral
    :math:`K(m) = \int_0^{\pi/2} [1 - m\sin^2 x]^{-1/2} dx`:
    
    >>> from scipy.special import ellipk
    >>> ellipk(0.8)
    2.2572053268208538
",function,"('tck', 'n')","(nan, 1)","(nan, 'int')","('arg_info', 'arg_info')","('(tck, n=1)',)"
scipy,1.1.0,scipy.interpolate.fitpack.splder,interpolate.fitpack,splder,"Python Library Documentation: function splder in module scipy.interpolate.fitpack

splder(tck, n=1)
    Compute the spline representation of the derivative of a given spline
    
    Parameters
    ----------
    tck : BSpline instance or a tuple of (t, c, k)
        Spline whose derivative to compute
    n : int, optional
        Order of derivative to evaluate. Default: 1
    
    Returns
    -------
    `BSpline` instance or tuple
        Spline of order k2=k-n representing the derivative
        of the input spline.
        A tuple is returned iff the input argument `tck` is a tuple, otherwise
        a BSpline object is constructed and returned.
    
    Notes
    -----
    
    .. versionadded:: 0.13.0
    
    See Also
    --------
    splantider, splev, spalde
    BSpline
    
    Examples
    --------
    This can be used for finding maxima of a curve:
    
    >>> from scipy.interpolate import splrep, splder, sproot
    >>> x = np.linspace(0, 10, 70)
    >>> y = np.sin(x)
    >>> spl = splrep(x, y, k=4)
    
    Now, differentiate the spline and find the zeros of the
    derivative. (NB: `sproot` only works for order 3 splines, so we
    fit an order 4 spline):
    
    >>> dspl = splder(spl)
    >>> sproot(dspl) / np.pi
    array([ 0.50000001,  1.5       ,  2.49999998])
    
    This agrees well with roots :math:`\pi/2 + n\pi` of
    :math:`\cos(x) = \sin'(x)`.
",function,"('(tck, n=1)',)",scipy,1.1.0,scipy.interpolate.fitpack.splder,interpolate.fitpack,splder,"Python Library Documentation: function splder in module scipy.interpolate.fitpack

splder(tck, n=1)
    Compute the spline representation of the derivative of a given spline
    
    Parameters
    ----------
    tck : BSpline instance or a tuple of (t, c, k)
        Spline whose derivative to compute
    n : int, optional
        Order of derivative to evaluate. Default: 1
    
    Returns
    -------
    `BSpline` instance or tuple
        Spline of order k2=k-n representing the derivative
        of the input spline.
        A tuple is returned iff the input argument `tck` is a tuple, otherwise
        a BSpline object is constructed and returned.
    
    Notes
    -----
    
    .. versionadded:: 0.13.0
    
    See Also
    --------
    splantider, splev, spalde
    BSpline
    
    Examples
    --------
    This can be used for finding maxima of a curve:
    
    >>> from scipy.interpolate import splrep, splder, sproot
    >>> x = np.linspace(0, 10, 70)
    >>> y = np.sin(x)
    >>> spl = splrep(x, y, k=4)
    
    Now, differentiate the spline and find the zeros of the
    derivative. (NB: `sproot` only works for order 3 splines, so we
    fit an order 4 spline):
    
    >>> dspl = splder(spl)
    >>> sproot(dspl) / np.pi
    array([ 0.50000001,  1.5       ,  2.49999998])
    
    This agrees well with roots :math:`\pi/2 + n\pi` of
    :math:`\cos(x) = \sin'(x)`.
",function,"('tck', 'n')","(nan, 1)","(nan, 'int')","('arg_info', 'arg_info')","('(tck, n=1)',)"
scipy,1.1.0,scipy.interpolate.fitpack.splev,interpolate.fitpack,splev,"Python Library Documentation: function splev in module scipy.interpolate.fitpack

splev(x, tck, der=0, ext=0)
    Evaluate a B-spline or its derivatives.
    
    Given the knots and coefficients of a B-spline representation, evaluate
    the value of the smoothing polynomial and its derivatives.  This is a
    wrapper around the FORTRAN routines splev and splder of FITPACK.
    
    Parameters
    ----------
    x : array_like
        An array of points at which to return the value of the smoothed
        spline or its derivatives.  If `tck` was returned from `splprep`,
        then the parameter values, u should be given.
    tck : 3-tuple or a BSpline object
        If a tuple, then it should be a sequence of length 3 returned by
        `splrep` or `splprep` containing the knots, coefficients, and degree
        of the spline. (Also see Notes.)
    der : int, optional
        The order of derivative of the spline to compute (must be less than
        or equal to k).
    ext : int, optional
        Controls the value returned for elements of ``x`` not in the
        interval defined by the knot sequence.
    
        * if ext=0, return the extrapolated value.
        * if ext=1, return 0
        * if ext=2, raise a ValueError
        * if ext=3, return the boundary value.
    
        The default value is 0.
    
    Returns
    -------
    y : ndarray or list of ndarrays
        An array of values representing the spline function evaluated at
        the points in `x`.  If `tck` was returned from `splprep`, then this
        is a list of arrays representing the curve in N-dimensional space.
    
    Notes
    -----
    Manipulating the tck-tuples directly is not recommended. In new code,
    prefer using `BSpline` objects.
    
    See Also
    --------
    splprep, splrep, sproot, spalde, splint
    bisplrep, bisplev
    BSpline
    
    References
    ----------
    .. [1] C. de Boor, ""On calculating with b-splines"", J. Approximation
        Theory, 6, p.50-62, 1972.
    .. [2] M. G. Cox, ""The numerical evaluation of b-splines"", J. Inst. Maths
        Applics, 10, p.134-149, 1972.
    .. [3] P. Dierckx, ""Curve and surface fitting with splines"", Monographs
        on Numerical Analysis, Oxford University Press, 1993.
",function,"('(x, tck, der=0, ext=0)',)",scipy,1.1.0,scipy.interpolate.fitpack.splev,interpolate.fitpack,splev,"Python Library Documentation: function splev in module scipy.interpolate.fitpack

splev(x, tck, der=0, ext=0)
    Evaluate a B-spline or its derivatives.
    
    Given the knots and coefficients of a B-spline representation, evaluate
    the value of the smoothing polynomial and its derivatives.  This is a
    wrapper around the FORTRAN routines splev and splder of FITPACK.
    
    Parameters
    ----------
    x : array_like
        An array of points at which to return the value of the smoothed
        spline or its derivatives.  If `tck` was returned from `splprep`,
        then the parameter values, u should be given.
    tck : 3-tuple or a BSpline object
        If a tuple, then it should be a sequence of length 3 returned by
        `splrep` or `splprep` containing the knots, coefficients, and degree
        of the spline. (Also see Notes.)
    der : int, optional
        The order of derivative of the spline to compute (must be less than
        or equal to k).
    ext : int, optional
        Controls the value returned for elements of ``x`` not in the
        interval defined by the knot sequence.
    
        * if ext=0, return the extrapolated value.
        * if ext=1, return 0
        * if ext=2, raise a ValueError
        * if ext=3, return the boundary value.
    
        The default value is 0.
    
    Returns
    -------
    y : ndarray or list of ndarrays
        An array of values representing the spline function evaluated at
        the points in `x`.  If `tck` was returned from `splprep`, then this
        is a list of arrays representing the curve in N-dimensional space.
    
    Notes
    -----
    Manipulating the tck-tuples directly is not recommended. In new code,
    prefer using `BSpline` objects.
    
    See Also
    --------
    splprep, splrep, sproot, spalde, splint
    bisplrep, bisplev
    BSpline
    
    References
    ----------
    .. [1] C. de Boor, ""On calculating with b-splines"", J. Approximation
        Theory, 6, p.50-62, 1972.
    .. [2] M. G. Cox, ""The numerical evaluation of b-splines"", J. Inst. Maths
        Applics, 10, p.134-149, 1972.
    .. [3] P. Dierckx, ""Curve and surface fitting with splines"", Monographs
        on Numerical Analysis, Oxford University Press, 1993.
",function,"('x', 'tck', 'der', 'ext')","(nan, nan, 0, 0)","(nan, nan, 'int', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, tck, der=0, ext=0)',)"
scipy,1.1.0,scipy.interpolate.fitpack.splint,interpolate.fitpack,splint,"Python Library Documentation: function splint in module scipy.interpolate.fitpack

splint(a, b, tck, full_output=0)
    Evaluate the definite integral of a B-spline between two given points.
    
    Parameters
    ----------
    a, b : float
        The end-points of the integration interval.
    tck : tuple or a BSpline instance
        If a tuple, then it should be a sequence of length 3, containing the
        vector of knots, the B-spline coefficients, and the degree of the
        spline (see `splev`).
    full_output : int, optional
        Non-zero to return optional output.
    
    Returns
    -------
    integral : float
        The resulting integral.
    wrk : ndarray
        An array containing the integrals of the normalized B-splines
        defined on the set of knots.
        (Only returned if `full_output` is non-zero)
    
    Notes
    -----
    `splint` silently assumes that the spline function is zero outside the data
    interval (`a`, `b`).
    
    Manipulating the tck-tuples directly is not recommended. In new code,
    prefer using the `BSpline` objects.
    
    See Also
    --------
    splprep, splrep, sproot, spalde, splev
    bisplrep, bisplev
    BSpline
    
    References
    ----------
    .. [1] P.W. Gaffney, The calculation of indefinite integrals of b-splines"",
        J. Inst. Maths Applics, 17, p.37-41, 1976.
    .. [2] P. Dierckx, ""Curve and surface fitting with splines"", Monographs
        on Numerical Analysis, Oxford University Press, 1993.
",function,"('(a, b, tck, full_output=0)',)",scipy,1.1.0,scipy.interpolate.fitpack.splint,interpolate.fitpack,splint,"Python Library Documentation: function splint in module scipy.interpolate.fitpack

splint(a, b, tck, full_output=0)
    Evaluate the definite integral of a B-spline between two given points.
    
    Parameters
    ----------
    a, b : float
        The end-points of the integration interval.
    tck : tuple or a BSpline instance
        If a tuple, then it should be a sequence of length 3, containing the
        vector of knots, the B-spline coefficients, and the degree of the
        spline (see `splev`).
    full_output : int, optional
        Non-zero to return optional output.
    
    Returns
    -------
    integral : float
        The resulting integral.
    wrk : ndarray
        An array containing the integrals of the normalized B-splines
        defined on the set of knots.
        (Only returned if `full_output` is non-zero)
    
    Notes
    -----
    `splint` silently assumes that the spline function is zero outside the data
    interval (`a`, `b`).
    
    Manipulating the tck-tuples directly is not recommended. In new code,
    prefer using the `BSpline` objects.
    
    See Also
    --------
    splprep, splrep, sproot, spalde, splev
    bisplrep, bisplev
    BSpline
    
    References
    ----------
    .. [1] P.W. Gaffney, The calculation of indefinite integrals of b-splines"",
        J. Inst. Maths Applics, 17, p.37-41, 1976.
    .. [2] P. Dierckx, ""Curve and surface fitting with splines"", Monographs
        on Numerical Analysis, Oxford University Press, 1993.
",function,"('a', 'b', 'tck', 'full_output')","(nan, nan, nan, 0)","(nan, nan, nan, 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, b, tck, full_output=0)',)"
scipy,1.1.0,scipy.interpolate.fitpack.splprep,interpolate.fitpack,splprep,"Python Library Documentation: function splprep in module scipy.interpolate.fitpack

splprep(x, w=None, u=None, ub=None, ue=None, k=3, task=0, s=None, t=None, full_output=0, nest=None, per=0, quiet=1)
    Find the B-spline representation of an N-dimensional curve.
    
    Given a list of N rank-1 arrays, `x`, which represent a curve in
    N-dimensional space parametrized by `u`, find a smooth approximating
    spline curve g(`u`). Uses the FORTRAN routine parcur from FITPACK.
    
    Parameters
    ----------
    x : array_like
        A list of sample vector arrays representing the curve.
    w : array_like, optional
        Strictly positive rank-1 array of weights the same length as `x[0]`.
        The weights are used in computing the weighted least-squares spline
        fit. If the errors in the `x` values have standard-deviation given by
        the vector d, then `w` should be 1/d. Default is ``ones(len(x[0]))``.
    u : array_like, optional
        An array of parameter values. If not given, these values are
        calculated automatically as ``M = len(x[0])``, where
    
            v[0] = 0
    
            v[i] = v[i-1] + distance(`x[i]`, `x[i-1]`)
    
            u[i] = v[i] / v[M-1]
    
    ub, ue : int, optional
        The end-points of the parameters interval.  Defaults to
        u[0] and u[-1].
    k : int, optional
        Degree of the spline. Cubic splines are recommended.
        Even values of `k` should be avoided especially with a small s-value.
        ``1 <= k <= 5``, default is 3.
    task : int, optional
        If task==0 (default), find t and c for a given smoothing factor, s.
        If task==1, find t and c for another value of the smoothing factor, s.
        There must have been a previous call with task=0 or task=1
        for the same set of data.
        If task=-1 find the weighted least square spline for a given set of
        knots, t.
    s : float, optional
        A smoothing condition.  The amount of smoothness is determined by
        satisfying the conditions: ``sum((w * (y - g))**2,axis=0) <= s``,
        where g(x) is the smoothed interpolation of (x,y).  The user can
        use `s` to control the trade-off between closeness and smoothness
        of fit.  Larger `s` means more smoothing while smaller values of `s`
        indicate less smoothing. Recommended values of `s` depend on the
        weights, w.  If the weights represent the inverse of the
        standard-deviation of y, then a good `s` value should be found in
        the range ``(m-sqrt(2*m),m+sqrt(2*m))``, where m is the number of
        data points in x, y, and w.
    t : int, optional
        The knots needed for task=-1.
    full_output : int, optional
        If non-zero, then return optional outputs.
    nest : int, optional
        An over-estimate of the total number of knots of the spline to
        help in determining the storage space.  By default nest=m/2.
        Always large enough is nest=m+k+1.
    per : int, optional
       If non-zero, data points are considered periodic with period
       ``x[m-1] - x[0]`` and a smooth periodic spline approximation is
       returned.  Values of ``y[m-1]`` and ``w[m-1]`` are not used.
    quiet : int, optional
         Non-zero to suppress messages.
         This parameter is deprecated; use standard Python warning filters
         instead.
    
    Returns
    -------
    tck : tuple
        (t,c,k) a tuple containing the vector of knots, the B-spline
        coefficients, and the degree of the spline.
    u : array
        An array of the values of the parameter.
    fp : float
        The weighted sum of squared residuals of the spline approximation.
    ier : int
        An integer flag about splrep success.  Success is indicated
        if ier<=0. If ier in [1,2,3] an error occurred but was not raised.
        Otherwise an error is raised.
    msg : str
        A message corresponding to the integer flag, ier.
    
    See Also
    --------
    splrep, splev, sproot, spalde, splint,
    bisplrep, bisplev
    UnivariateSpline, BivariateSpline
    BSpline
    make_interp_spline
    
    Notes
    -----
    See `splev` for evaluation of the spline and its derivatives.
    The number of dimensions N must be smaller than 11.
    
    The number of coefficients in the `c` array is ``k+1`` less then the number
    of knots, ``len(t)``. This is in contrast with `splrep`, which zero-pads
    the array of coefficients to have the same length as the array of knots.
    These additional coefficients are ignored by evaluation routines, `splev`
    and `BSpline`.
    
    References
    ----------
    .. [1] P. Dierckx, ""Algorithms for smoothing data with periodic and
        parametric splines, Computer Graphics and Image Processing"",
        20 (1982) 171-184.
    .. [2] P. Dierckx, ""Algorithms for smoothing data with periodic and
        parametric splines"", report tw55, Dept. Computer Science,
        K.U.Leuven, 1981.
    .. [3] P. Dierckx, ""Curve and surface fitting with splines"", Monographs on
        Numerical Analysis, Oxford University Press, 1993.
    
    Examples
    --------
    Generate a discretization of a limacon curve in the polar coordinates:
    
    >>> phi = np.linspace(0, 2.*np.pi, 40)
    >>> r = 0.5 + np.cos(phi)         # polar coords
    >>> x, y = r * np.cos(phi), r * np.sin(phi)    # convert to cartesian
    
    And interpolate:
    
    >>> from scipy.interpolate import splprep, splev
    >>> tck, u = splprep([x, y], s=0)
    >>> new_points = splev(u, tck)
    
    Notice that (i) we force interpolation by using `s=0`,
    (ii) the parameterization, ``u``, is generated automatically.
    Now plot the result:
    
    >>> import matplotlib.pyplot as plt
    >>> fig, ax = plt.subplots()
    >>> ax.plot(x, y, 'ro')
    >>> ax.plot(new_points[0], new_points[1], 'r-')
    >>> plt.show()
",function,"('(x, w=None, u=None, ub=None, ue=None, k=3, task=0, s=None, t=None, full_output=0, nest=None, per=0, quiet=1)',)",scipy,1.1.0,scipy.interpolate.fitpack.splprep,interpolate.fitpack,splprep,"Python Library Documentation: function splprep in module scipy.interpolate.fitpack

splprep(x, w=None, u=None, ub=None, ue=None, k=3, task=0, s=None, t=None, full_output=0, nest=None, per=0, quiet=1)
    Find the B-spline representation of an N-dimensional curve.
    
    Given a list of N rank-1 arrays, `x`, which represent a curve in
    N-dimensional space parametrized by `u`, find a smooth approximating
    spline curve g(`u`). Uses the FORTRAN routine parcur from FITPACK.
    
    Parameters
    ----------
    x : array_like
        A list of sample vector arrays representing the curve.
    w : array_like, optional
        Strictly positive rank-1 array of weights the same length as `x[0]`.
        The weights are used in computing the weighted least-squares spline
        fit. If the errors in the `x` values have standard-deviation given by
        the vector d, then `w` should be 1/d. Default is ``ones(len(x[0]))``.
    u : array_like, optional
        An array of parameter values. If not given, these values are
        calculated automatically as ``M = len(x[0])``, where
    
            v[0] = 0
    
            v[i] = v[i-1] + distance(`x[i]`, `x[i-1]`)
    
            u[i] = v[i] / v[M-1]
    
    ub, ue : int, optional
        The end-points of the parameters interval.  Defaults to
        u[0] and u[-1].
    k : int, optional
        Degree of the spline. Cubic splines are recommended.
        Even values of `k` should be avoided especially with a small s-value.
        ``1 <= k <= 5``, default is 3.
    task : int, optional
        If task==0 (default), find t and c for a given smoothing factor, s.
        If task==1, find t and c for another value of the smoothing factor, s.
        There must have been a previous call with task=0 or task=1
        for the same set of data.
        If task=-1 find the weighted least square spline for a given set of
        knots, t.
    s : float, optional
        A smoothing condition.  The amount of smoothness is determined by
        satisfying the conditions: ``sum((w * (y - g))**2,axis=0) <= s``,
        where g(x) is the smoothed interpolation of (x,y).  The user can
        use `s` to control the trade-off between closeness and smoothness
        of fit.  Larger `s` means more smoothing while smaller values of `s`
        indicate less smoothing. Recommended values of `s` depend on the
        weights, w.  If the weights represent the inverse of the
        standard-deviation of y, then a good `s` value should be found in
        the range ``(m-sqrt(2*m),m+sqrt(2*m))``, where m is the number of
        data points in x, y, and w.
    t : int, optional
        The knots needed for task=-1.
    full_output : int, optional
        If non-zero, then return optional outputs.
    nest : int, optional
        An over-estimate of the total number of knots of the spline to
        help in determining the storage space.  By default nest=m/2.
        Always large enough is nest=m+k+1.
    per : int, optional
       If non-zero, data points are considered periodic with period
       ``x[m-1] - x[0]`` and a smooth periodic spline approximation is
       returned.  Values of ``y[m-1]`` and ``w[m-1]`` are not used.
    quiet : int, optional
         Non-zero to suppress messages.
         This parameter is deprecated; use standard Python warning filters
         instead.
    
    Returns
    -------
    tck : tuple
        (t,c,k) a tuple containing the vector of knots, the B-spline
        coefficients, and the degree of the spline.
    u : array
        An array of the values of the parameter.
    fp : float
        The weighted sum of squared residuals of the spline approximation.
    ier : int
        An integer flag about splrep success.  Success is indicated
        if ier<=0. If ier in [1,2,3] an error occurred but was not raised.
        Otherwise an error is raised.
    msg : str
        A message corresponding to the integer flag, ier.
    
    See Also
    --------
    splrep, splev, sproot, spalde, splint,
    bisplrep, bisplev
    UnivariateSpline, BivariateSpline
    BSpline
    make_interp_spline
    
    Notes
    -----
    See `splev` for evaluation of the spline and its derivatives.
    The number of dimensions N must be smaller than 11.
    
    The number of coefficients in the `c` array is ``k+1`` less then the number
    of knots, ``len(t)``. This is in contrast with `splrep`, which zero-pads
    the array of coefficients to have the same length as the array of knots.
    These additional coefficients are ignored by evaluation routines, `splev`
    and `BSpline`.
    
    References
    ----------
    .. [1] P. Dierckx, ""Algorithms for smoothing data with periodic and
        parametric splines, Computer Graphics and Image Processing"",
        20 (1982) 171-184.
    .. [2] P. Dierckx, ""Algorithms for smoothing data with periodic and
        parametric splines"", report tw55, Dept. Computer Science,
        K.U.Leuven, 1981.
    .. [3] P. Dierckx, ""Curve and surface fitting with splines"", Monographs on
        Numerical Analysis, Oxford University Press, 1993.
    
    Examples
    --------
    Generate a discretization of a limacon curve in the polar coordinates:
    
    >>> phi = np.linspace(0, 2.*np.pi, 40)
    >>> r = 0.5 + np.cos(phi)         # polar coords
    >>> x, y = r * np.cos(phi), r * np.sin(phi)    # convert to cartesian
    
    And interpolate:
    
    >>> from scipy.interpolate import splprep, splev
    >>> tck, u = splprep([x, y], s=0)
    >>> new_points = splev(u, tck)
    
    Notice that (i) we force interpolation by using `s=0`,
    (ii) the parameterization, ``u``, is generated automatically.
    Now plot the result:
    
    >>> import matplotlib.pyplot as plt
    >>> fig, ax = plt.subplots()
    >>> ax.plot(x, y, 'ro')
    >>> ax.plot(new_points[0], new_points[1], 'r-')
    >>> plt.show()
",function,"('x', 'w', 'u', 'ub', 'ue', 'k', 'task', 's', 't', 'full_output', 'nest', 'per', 'quiet')","(nan, None, None, None, None, 3, 0, None, None, 0, None, 0, 1)","(nan, 'NoneType', 'NoneType', 'NoneType', 'NoneType', 'int', 'int', 'NoneType', 'NoneType', 'int', 'NoneType', 'int', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, w=None, u=None, ub=None, ue=None, k=3, task=0, s=None, t=None, full_output=0, nest=None, per=0, quiet=1)',)"
scipy,1.1.0,scipy.interpolate.fitpack.splrep,interpolate.fitpack,splrep,"Python Library Documentation: function splrep in module scipy.interpolate.fitpack

splrep(x, y, w=None, xb=None, xe=None, k=3, task=0, s=None, t=None, full_output=0, per=0, quiet=1)
    Find the B-spline representation of 1-D curve.
    
    Given the set of data points ``(x[i], y[i])`` determine a smooth spline
    approximation of degree k on the interval ``xb <= x <= xe``.
    
    Parameters
    ----------
    x, y : array_like
        The data points defining a curve y = f(x).
    w : array_like, optional
        Strictly positive rank-1 array of weights the same length as x and y.
        The weights are used in computing the weighted least-squares spline
        fit. If the errors in the y values have standard-deviation given by the
        vector d, then w should be 1/d. Default is ones(len(x)).
    xb, xe : float, optional
        The interval to fit.  If None, these default to x[0] and x[-1]
        respectively.
    k : int, optional
        The degree of the spline fit. It is recommended to use cubic splines.
        Even values of k should be avoided especially with small s values.
        1 <= k <= 5
    task : {1, 0, -1}, optional
        If task==0 find t and c for a given smoothing factor, s.
    
        If task==1 find t and c for another value of the smoothing factor, s.
        There must have been a previous call with task=0 or task=1 for the same
        set of data (t will be stored an used internally)
    
        If task=-1 find the weighted least square spline for a given set of
        knots, t. These should be interior knots as knots on the ends will be
        added automatically.
    s : float, optional
        A smoothing condition. The amount of smoothness is determined by
        satisfying the conditions: sum((w * (y - g))**2,axis=0) <= s where g(x)
        is the smoothed interpolation of (x,y). The user can use s to control
        the tradeoff between closeness and smoothness of fit. Larger s means
        more smoothing while smaller values of s indicate less smoothing.
        Recommended values of s depend on the weights, w. If the weights
        represent the inverse of the standard-deviation of y, then a good s
        value should be found in the range (m-sqrt(2*m),m+sqrt(2*m)) where m is
        the number of datapoints in x, y, and w. default : s=m-sqrt(2*m) if
        weights are supplied. s = 0.0 (interpolating) if no weights are
        supplied.
    t : array_like, optional
        The knots needed for task=-1. If given then task is automatically set
        to -1.
    full_output : bool, optional
        If non-zero, then return optional outputs.
    per : bool, optional
        If non-zero, data points are considered periodic with period x[m-1] -
        x[0] and a smooth periodic spline approximation is returned. Values of
        y[m-1] and w[m-1] are not used.
    quiet : bool, optional
        Non-zero to suppress messages.
        This parameter is deprecated; use standard Python warning filters
        instead.
    
    Returns
    -------
    tck : tuple
        A tuple (t,c,k) containing the vector of knots, the B-spline
        coefficients, and the degree of the spline.
    fp : array, optional
        The weighted sum of squared residuals of the spline approximation.
    ier : int, optional
        An integer flag about splrep success. Success is indicated if ier<=0.
        If ier in [1,2,3] an error occurred but was not raised. Otherwise an
        error is raised.
    msg : str, optional
        A message corresponding to the integer flag, ier.
    
    See Also
    --------
    UnivariateSpline, BivariateSpline
    splprep, splev, sproot, spalde, splint
    bisplrep, bisplev
    BSpline
    make_interp_spline
    
    Notes
    -----
    See `splev` for evaluation of the spline and its derivatives. Uses the
    FORTRAN routine ``curfit`` from FITPACK.
    
    The user is responsible for assuring that the values of `x` are unique.
    Otherwise, `splrep` will not return sensible results.
    
    If provided, knots `t` must satisfy the Schoenberg-Whitney conditions,
    i.e., there must be a subset of data points ``x[j]`` such that
    ``t[j] < x[j] < t[j+k+1]``, for ``j=0, 1,...,n-k-2``.
    
    This routine zero-pads the coefficients array ``c`` to have the same length
    as the array of knots ``t`` (the trailing ``k + 1`` coefficients are ignored
    by the evaluation routines, `splev` and `BSpline`.) This is in contrast with
    `splprep`, which does not zero-pad the coefficients.
    
    References
    ----------
    Based on algorithms described in [1]_, [2]_, [3]_, and [4]_:
    
    .. [1] P. Dierckx, ""An algorithm for smoothing, differentiation and
       integration of experimental data using spline functions"",
       J.Comp.Appl.Maths 1 (1975) 165-184.
    .. [2] P. Dierckx, ""A fast algorithm for smoothing data on a rectangular
       grid while using spline functions"", SIAM J.Numer.Anal. 19 (1982)
       1286-1304.
    .. [3] P. Dierckx, ""An improved algorithm for curve fitting with spline
       functions"", report tw54, Dept. Computer Science,K.U. Leuven, 1981.
    .. [4] P. Dierckx, ""Curve and surface fitting with splines"", Monographs on
       Numerical Analysis, Oxford University Press, 1993.
    
    Examples
    --------
    
    >>> import matplotlib.pyplot as plt
    >>> from scipy.interpolate import splev, splrep
    >>> x = np.linspace(0, 10, 10)
    >>> y = np.sin(x)
    >>> spl = splrep(x, y)
    >>> x2 = np.linspace(0, 10, 200)
    >>> y2 = splev(x2, spl)
    >>> plt.plot(x, y, 'o', x2, y2)
    >>> plt.show()
",function,"('(x, y, w=None, xb=None, xe=None, k=3, task=0, s=None, t=None, full_output=0, per=0, quiet=1)',)",scipy,1.1.0,scipy.interpolate.fitpack.splrep,interpolate.fitpack,splrep,"Python Library Documentation: function splrep in module scipy.interpolate.fitpack

splrep(x, y, w=None, xb=None, xe=None, k=3, task=0, s=None, t=None, full_output=0, per=0, quiet=1)
    Find the B-spline representation of 1-D curve.
    
    Given the set of data points ``(x[i], y[i])`` determine a smooth spline
    approximation of degree k on the interval ``xb <= x <= xe``.
    
    Parameters
    ----------
    x, y : array_like
        The data points defining a curve y = f(x).
    w : array_like, optional
        Strictly positive rank-1 array of weights the same length as x and y.
        The weights are used in computing the weighted least-squares spline
        fit. If the errors in the y values have standard-deviation given by the
        vector d, then w should be 1/d. Default is ones(len(x)).
    xb, xe : float, optional
        The interval to fit.  If None, these default to x[0] and x[-1]
        respectively.
    k : int, optional
        The degree of the spline fit. It is recommended to use cubic splines.
        Even values of k should be avoided especially with small s values.
        1 <= k <= 5
    task : {1, 0, -1}, optional
        If task==0 find t and c for a given smoothing factor, s.
    
        If task==1 find t and c for another value of the smoothing factor, s.
        There must have been a previous call with task=0 or task=1 for the same
        set of data (t will be stored an used internally)
    
        If task=-1 find the weighted least square spline for a given set of
        knots, t. These should be interior knots as knots on the ends will be
        added automatically.
    s : float, optional
        A smoothing condition. The amount of smoothness is determined by
        satisfying the conditions: sum((w * (y - g))**2,axis=0) <= s where g(x)
        is the smoothed interpolation of (x,y). The user can use s to control
        the tradeoff between closeness and smoothness of fit. Larger s means
        more smoothing while smaller values of s indicate less smoothing.
        Recommended values of s depend on the weights, w. If the weights
        represent the inverse of the standard-deviation of y, then a good s
        value should be found in the range (m-sqrt(2*m),m+sqrt(2*m)) where m is
        the number of datapoints in x, y, and w. default : s=m-sqrt(2*m) if
        weights are supplied. s = 0.0 (interpolating) if no weights are
        supplied.
    t : array_like, optional
        The knots needed for task=-1. If given then task is automatically set
        to -1.
    full_output : bool, optional
        If non-zero, then return optional outputs.
    per : bool, optional
        If non-zero, data points are considered periodic with period x[m-1] -
        x[0] and a smooth periodic spline approximation is returned. Values of
        y[m-1] and w[m-1] are not used.
    quiet : bool, optional
        Non-zero to suppress messages.
        This parameter is deprecated; use standard Python warning filters
        instead.
    
    Returns
    -------
    tck : tuple
        A tuple (t,c,k) containing the vector of knots, the B-spline
        coefficients, and the degree of the spline.
    fp : array, optional
        The weighted sum of squared residuals of the spline approximation.
    ier : int, optional
        An integer flag about splrep success. Success is indicated if ier<=0.
        If ier in [1,2,3] an error occurred but was not raised. Otherwise an
        error is raised.
    msg : str, optional
        A message corresponding to the integer flag, ier.
    
    See Also
    --------
    UnivariateSpline, BivariateSpline
    splprep, splev, sproot, spalde, splint
    bisplrep, bisplev
    BSpline
    make_interp_spline
    
    Notes
    -----
    See `splev` for evaluation of the spline and its derivatives. Uses the
    FORTRAN routine ``curfit`` from FITPACK.
    
    The user is responsible for assuring that the values of `x` are unique.
    Otherwise, `splrep` will not return sensible results.
    
    If provided, knots `t` must satisfy the Schoenberg-Whitney conditions,
    i.e., there must be a subset of data points ``x[j]`` such that
    ``t[j] < x[j] < t[j+k+1]``, for ``j=0, 1,...,n-k-2``.
    
    This routine zero-pads the coefficients array ``c`` to have the same length
    as the array of knots ``t`` (the trailing ``k + 1`` coefficients are ignored
    by the evaluation routines, `splev` and `BSpline`.) This is in contrast with
    `splprep`, which does not zero-pad the coefficients.
    
    References
    ----------
    Based on algorithms described in [1]_, [2]_, [3]_, and [4]_:
    
    .. [1] P. Dierckx, ""An algorithm for smoothing, differentiation and
       integration of experimental data using spline functions"",
       J.Comp.Appl.Maths 1 (1975) 165-184.
    .. [2] P. Dierckx, ""A fast algorithm for smoothing data on a rectangular
       grid while using spline functions"", SIAM J.Numer.Anal. 19 (1982)
       1286-1304.
    .. [3] P. Dierckx, ""An improved algorithm for curve fitting with spline
       functions"", report tw54, Dept. Computer Science,K.U. Leuven, 1981.
    .. [4] P. Dierckx, ""Curve and surface fitting with splines"", Monographs on
       Numerical Analysis, Oxford University Press, 1993.
    
    Examples
    --------
    
    >>> import matplotlib.pyplot as plt
    >>> from scipy.interpolate import splev, splrep
    >>> x = np.linspace(0, 10, 10)
    >>> y = np.sin(x)
    >>> spl = splrep(x, y)
    >>> x2 = np.linspace(0, 10, 200)
    >>> y2 = splev(x2, spl)
    >>> plt.plot(x, y, 'o', x2, y2)
    >>> plt.show()
",function,"('x', 'y', 'w', 'xb', 'xe', 'k', 'task', 's', 't', 'full_output', 'per', 'quiet')","(nan, nan, None, None, None, 3, 0, None, None, 0, 0, 1)","(nan, nan, 'NoneType', 'NoneType', 'NoneType', 'int', 'int', 'NoneType', 'NoneType', 'int', 'int', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, y, w=None, xb=None, xe=None, k=3, task=0, s=None, t=None, full_output=0, per=0, quiet=1)',)"
scipy,1.1.0,scipy.interpolate.fitpack.sproot,interpolate.fitpack,sproot,"Python Library Documentation: function sproot in module scipy.interpolate.fitpack

sproot(tck, mest=10)
    Find the roots of a cubic B-spline.
    
    Given the knots (>=8) and coefficients of a cubic B-spline return the
    roots of the spline.
    
    Parameters
    ----------
    tck : tuple or a BSpline object
        If a tuple, then it should be a sequence of length 3, containing the
        vector of knots, the B-spline coefficients, and the degree of the
        spline.
        The number of knots must be >= 8, and the degree must be 3.
        The knots must be a montonically increasing sequence.
    mest : int, optional
        An estimate of the number of zeros (Default is 10).
    
    Returns
    -------
    zeros : ndarray
        An array giving the roots of the spline.
    
    Notes
    -----
    Manipulating the tck-tuples directly is not recommended. In new code,
    prefer using the `BSpline` objects.
    
    See also
    --------
    splprep, splrep, splint, spalde, splev
    bisplrep, bisplev
    BSpline
    
    
    References
    ----------
    .. [1] C. de Boor, ""On calculating with b-splines"", J. Approximation
        Theory, 6, p.50-62, 1972.
    .. [2] M. G. Cox, ""The numerical evaluation of b-splines"", J. Inst. Maths
        Applics, 10, p.134-149, 1972.
    .. [3] P. Dierckx, ""Curve and surface fitting with splines"", Monographs
        on Numerical Analysis, Oxford University Press, 1993.
",function,"('(tck, mest=10)',)",scipy,1.1.0,scipy.interpolate.fitpack.sproot,interpolate.fitpack,sproot,"Python Library Documentation: function sproot in module scipy.interpolate.fitpack

sproot(tck, mest=10)
    Find the roots of a cubic B-spline.
    
    Given the knots (>=8) and coefficients of a cubic B-spline return the
    roots of the spline.
    
    Parameters
    ----------
    tck : tuple or a BSpline object
        If a tuple, then it should be a sequence of length 3, containing the
        vector of knots, the B-spline coefficients, and the degree of the
        spline.
        The number of knots must be >= 8, and the degree must be 3.
        The knots must be a montonically increasing sequence.
    mest : int, optional
        An estimate of the number of zeros (Default is 10).
    
    Returns
    -------
    zeros : ndarray
        An array giving the roots of the spline.
    
    Notes
    -----
    Manipulating the tck-tuples directly is not recommended. In new code,
    prefer using the `BSpline` objects.
    
    See also
    --------
    splprep, splrep, splint, spalde, splev
    bisplrep, bisplev
    BSpline
    
    
    References
    ----------
    .. [1] C. de Boor, ""On calculating with b-splines"", J. Approximation
        Theory, 6, p.50-62, 1972.
    .. [2] M. G. Cox, ""The numerical evaluation of b-splines"", J. Inst. Maths
        Applics, 10, p.134-149, 1972.
    .. [3] P. Dierckx, ""Curve and surface fitting with splines"", Monographs
        on Numerical Analysis, Oxford University Press, 1993.
",function,"('tck', 'mest')","(nan, 10)","(nan, 'int')","('arg_info', 'arg_info')","('(tck, mest=10)',)"
scipy,1.1.0,scipy.interpolate.fitpack2.BivariateSpline,interpolate.fitpack2,BivariateSpline,"Python Library Documentation: class BivariateSpline in module scipy.interpolate.fitpack2

class BivariateSpline(_BivariateSplineBase)
 |  Base class for bivariate splines.
 |  
 |  This describes a spline ``s(x, y)`` of degrees ``kx`` and ``ky`` on
 |  the rectangle ``[xb, xe] * [yb, ye]`` calculated from a given set
 |  of data points ``(x, y, z)``.
 |  
 |  This class is meant to be subclassed, not instantiated directly.
 |  To construct these splines, call either `SmoothBivariateSpline` or
 |  `LSQBivariateSpline`.
 |  
 |  See Also
 |  --------
 |  UnivariateSpline : a similar class for univariate spline interpolation
 |  SmoothBivariateSpline :
 |      to create a BivariateSpline through the given points
 |  LSQBivariateSpline :
 |      to create a BivariateSpline using weighted least-squares fitting
 |  SphereBivariateSpline :
 |      bivariate spline interpolation in spherical cooridinates
 |  bisplrep : older wrapping of FITPACK
 |  bisplev : older wrapping of FITPACK
 |  
 |  Method resolution order:
 |      BivariateSpline
 |      _BivariateSplineBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  ev(self, xi, yi, dx=0, dy=0)
 |      Evaluate the spline at points
 |      
 |      Returns the interpolated value at ``(xi[i], yi[i]),
 |      i=0,...,len(xi)-1``.
 |      
 |      Parameters
 |      ----------
 |      xi, yi : array_like
 |          Input coordinates. Standard Numpy broadcasting is obeyed.
 |      dx : int, optional
 |          Order of x-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dy : int, optional
 |          Order of y-derivative
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  integral(self, xa, xb, ya, yb)
 |      Evaluate the integral of the spline over area [xa,xb] x [ya,yb].
 |      
 |      Parameters
 |      ----------
 |      xa, xb : float
 |          The end-points of the x integration interval.
 |      ya, yb : float
 |          The end-points of the y integration interval.
 |      
 |      Returns
 |      -------
 |      integ : float
 |          The value of the resulting integral.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BivariateSplineBase:
 |  
 |  __call__(self, x, y, dx=0, dy=0, grid=True)
 |      Evaluate the spline or its derivatives at given positions.
 |      
 |      Parameters
 |      ----------
 |      x, y : array_like
 |          Input coordinates.
 |      
 |          If `grid` is False, evaluate the spline at points ``(x[i],
 |          y[i]), i=0, ..., len(x)-1``.  Standard Numpy broadcasting
 |          is obeyed.
 |      
 |          If `grid` is True: evaluate spline at the grid points
 |          defined by the coordinate arrays x, y. The arrays must be
 |          sorted to increasing order.
 |          
 |          Note that the axis ordering is inverted relative to
 |          the output of meshgrid.
 |      dx : int
 |          Order of x-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dy : int
 |          Order of y-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      grid : bool
 |          Whether to evaluate the results on a grid spanned by the
 |          input arrays, or at points specified by the input arrays.
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  get_coeffs(self)
 |      Return spline coefficients.
 |  
 |  get_knots(self)
 |      Return a tuple (tx,ty) where tx,ty contain knots positions
 |      of the spline with respect to x-, y-variable, respectively.
 |      The position of interior and additional knots are given as
 |      t[k+1:-k-1] and t[:k+1]=b, t[-k-1:]=e, respectively.
 |  
 |  get_residual(self)
 |      Return weighted sum of squared residuals of the spline
 |      approximation: sum ((w[i]*(z[i]-s(x[i],y[i])))**2,axis=0)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BivariateSplineBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.interpolate.fitpack2.BivariateSpline,interpolate.fitpack2,BivariateSpline,"Python Library Documentation: class BivariateSpline in module scipy.interpolate.fitpack2

class BivariateSpline(_BivariateSplineBase)
 |  Base class for bivariate splines.
 |  
 |  This describes a spline ``s(x, y)`` of degrees ``kx`` and ``ky`` on
 |  the rectangle ``[xb, xe] * [yb, ye]`` calculated from a given set
 |  of data points ``(x, y, z)``.
 |  
 |  This class is meant to be subclassed, not instantiated directly.
 |  To construct these splines, call either `SmoothBivariateSpline` or
 |  `LSQBivariateSpline`.
 |  
 |  See Also
 |  --------
 |  UnivariateSpline : a similar class for univariate spline interpolation
 |  SmoothBivariateSpline :
 |      to create a BivariateSpline through the given points
 |  LSQBivariateSpline :
 |      to create a BivariateSpline using weighted least-squares fitting
 |  SphereBivariateSpline :
 |      bivariate spline interpolation in spherical cooridinates
 |  bisplrep : older wrapping of FITPACK
 |  bisplev : older wrapping of FITPACK
 |  
 |  Method resolution order:
 |      BivariateSpline
 |      _BivariateSplineBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  ev(self, xi, yi, dx=0, dy=0)
 |      Evaluate the spline at points
 |      
 |      Returns the interpolated value at ``(xi[i], yi[i]),
 |      i=0,...,len(xi)-1``.
 |      
 |      Parameters
 |      ----------
 |      xi, yi : array_like
 |          Input coordinates. Standard Numpy broadcasting is obeyed.
 |      dx : int, optional
 |          Order of x-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dy : int, optional
 |          Order of y-derivative
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  integral(self, xa, xb, ya, yb)
 |      Evaluate the integral of the spline over area [xa,xb] x [ya,yb].
 |      
 |      Parameters
 |      ----------
 |      xa, xb : float
 |          The end-points of the x integration interval.
 |      ya, yb : float
 |          The end-points of the y integration interval.
 |      
 |      Returns
 |      -------
 |      integ : float
 |          The value of the resulting integral.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BivariateSplineBase:
 |  
 |  __call__(self, x, y, dx=0, dy=0, grid=True)
 |      Evaluate the spline or its derivatives at given positions.
 |      
 |      Parameters
 |      ----------
 |      x, y : array_like
 |          Input coordinates.
 |      
 |          If `grid` is False, evaluate the spline at points ``(x[i],
 |          y[i]), i=0, ..., len(x)-1``.  Standard Numpy broadcasting
 |          is obeyed.
 |      
 |          If `grid` is True: evaluate spline at the grid points
 |          defined by the coordinate arrays x, y. The arrays must be
 |          sorted to increasing order.
 |          
 |          Note that the axis ordering is inverted relative to
 |          the output of meshgrid.
 |      dx : int
 |          Order of x-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dy : int
 |          Order of y-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      grid : bool
 |          Whether to evaluate the results on a grid spanned by the
 |          input arrays, or at points specified by the input arrays.
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  get_coeffs(self)
 |      Return spline coefficients.
 |  
 |  get_knots(self)
 |      Return a tuple (tx,ty) where tx,ty contain knots positions
 |      of the spline with respect to x-, y-variable, respectively.
 |      The position of interior and additional knots are given as
 |      t[k+1:-k-1] and t[:k+1]=b, t[-k-1:]=e, respectively.
 |  
 |  get_residual(self)
 |      Return weighted sum of squared residuals of the spline
 |      approximation: sum ((w[i]*(z[i]-s(x[i],y[i])))**2,axis=0)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BivariateSplineBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.interpolate.fitpack2.BivariateSpline._from_tck,interpolate.fitpack2.BivariateSpline,_from_tck,"Python Library Documentation: method _from_tck in module scipy.interpolate.fitpack2

_from_tck(tck) method of builtins.type instance
    Construct a spline object from given tck and degree
",method,"('(tck)',)",scipy,1.1.0,scipy.interpolate.fitpack2.BivariateSpline._from_tck,interpolate.fitpack2.BivariateSpline,_from_tck,"Python Library Documentation: method _from_tck in module scipy.interpolate.fitpack2

_from_tck(tck) method of builtins.type instance
    Construct a spline object from given tck and degree
",method,"('cls', 'tck')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(tck)',)"
scipy,1.1.0,scipy.interpolate.fitpack2.InterpolatedUnivariateSpline,interpolate.fitpack2,InterpolatedUnivariateSpline,"Python Library Documentation: class InterpolatedUnivariateSpline in module scipy.interpolate.fitpack2

class InterpolatedUnivariateSpline(UnivariateSpline)
 |  One-dimensional interpolating spline for a given set of data points.
 |  
 |  Fits a spline y = spl(x) of degree `k` to the provided `x`, `y` data. Spline
 |  function passes through all provided points. Equivalent to
 |  `UnivariateSpline` with  s=0.
 |  
 |  Parameters
 |  ----------
 |  x : (N,) array_like
 |      Input dimension of data points -- must be increasing
 |  y : (N,) array_like
 |      input dimension of data points
 |  w : (N,) array_like, optional
 |      Weights for spline fitting.  Must be positive.  If None (default),
 |      weights are all equal.
 |  bbox : (2,) array_like, optional
 |      2-sequence specifying the boundary of the approximation interval. If
 |      None (default), ``bbox=[x[0], x[-1]]``.
 |  k : int, optional
 |      Degree of the smoothing spline.  Must be 1 <= `k` <= 5.
 |  ext : int or str, optional
 |      Controls the extrapolation mode for elements
 |      not in the interval defined by the knot sequence.
 |  
 |      * if ext=0 or 'extrapolate', return the extrapolated value.
 |      * if ext=1 or 'zeros', return 0
 |      * if ext=2 or 'raise', raise a ValueError
 |      * if ext=3 of 'const', return the boundary value.
 |  
 |      The default value is 0.
 |  
 |  check_finite : bool, optional
 |      Whether to check that the input arrays contain only finite numbers.
 |      Disabling may give a performance gain, but may result in problems
 |      (crashes, non-termination or non-sensical results) if the inputs
 |      do contain infinities or NaNs.
 |      Default is False.
 |  
 |  See Also
 |  --------
 |  UnivariateSpline : Superclass -- allows knots to be selected by a
 |      smoothing condition
 |  LSQUnivariateSpline : spline for which knots are user-selected
 |  splrep : An older, non object-oriented wrapping of FITPACK
 |  splev, sproot, splint, spalde
 |  BivariateSpline : A similar class for two-dimensional spline interpolation
 |  
 |  Notes
 |  -----
 |  The number of data points must be larger than the spline degree `k`.
 |  
 |  Examples
 |  --------
 |  >>> import matplotlib.pyplot as plt
 |  >>> from scipy.interpolate import InterpolatedUnivariateSpline
 |  >>> x = np.linspace(-3, 3, 50)
 |  >>> y = np.exp(-x**2) + 0.1 * np.random.randn(50)
 |  >>> spl = InterpolatedUnivariateSpline(x, y)
 |  >>> plt.plot(x, y, 'ro', ms=5)
 |  >>> xs = np.linspace(-3, 3, 1000)
 |  >>> plt.plot(xs, spl(xs), 'g', lw=3, alpha=0.7)
 |  >>> plt.show()
 |  
 |  Notice that the ``spl(x)`` interpolates `y`:
 |  
 |  >>> spl.get_residual()
 |  0.0
 |  
 |  Method resolution order:
 |      InterpolatedUnivariateSpline
 |      UnivariateSpline
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, x, y, w=None, bbox=[None, None], k=3, ext=0, check_finite=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from UnivariateSpline:
 |  
 |  __call__(self, x, nu=0, ext=None)
 |      Evaluate spline (or its nu-th derivative) at positions x.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          A 1-D array of points at which to return the value of the smoothed
 |          spline or its derivatives. Note: x can be unordered but the
 |          evaluation is more efficient if x is (partially) ordered.
 |      nu  : int
 |          The order of derivative of the spline to compute.
 |      ext : int
 |          Controls the value returned for elements of ``x`` not in the
 |          interval defined by the knot sequence.
 |      
 |          * if ext=0 or 'extrapolate', return the extrapolated value.
 |          * if ext=1 or 'zeros', return 0
 |          * if ext=2 or 'raise', raise a ValueError
 |          * if ext=3 or 'const', return the boundary value.
 |      
 |          The default value is 0, passed from the initialization of
 |          UnivariateSpline.
 |  
 |  antiderivative(self, n=1)
 |      Construct a new spline representing the antiderivative of this spline.
 |      
 |      Parameters
 |      ----------
 |      n : int, optional
 |          Order of antiderivative to evaluate. Default: 1
 |      
 |      Returns
 |      -------
 |      spline : UnivariateSpline
 |          Spline of order k2=k+n representing the antiderivative of this
 |          spline.
 |      
 |      Notes
 |      -----
 |      
 |      .. versionadded:: 0.13.0
 |      
 |      See Also
 |      --------
 |      splantider, derivative
 |      
 |      Examples
 |      --------
 |      >>> from scipy.interpolate import UnivariateSpline
 |      >>> x = np.linspace(0, np.pi/2, 70)
 |      >>> y = 1 / np.sqrt(1 - 0.8*np.sin(x)**2)
 |      >>> spl = UnivariateSpline(x, y, s=0)
 |      
 |      The derivative is the inverse operation of the antiderivative,
 |      although some floating point error accumulates:
 |      
 |      >>> spl(1.7), spl.antiderivative().derivative()(1.7)
 |      (array(2.1565429877197317), array(2.1565429877201865))
 |      
 |      Antiderivative can be used to evaluate definite integrals:
 |      
 |      >>> ispl = spl.antiderivative()
 |      >>> ispl(np.pi/2) - ispl(0)
 |      2.2572053588768486
 |      
 |      This is indeed an approximation to the complete elliptic integral
 |      :math:`K(m) = \int_0^{\pi/2} [1 - m\sin^2 x]^{-1/2} dx`:
 |      
 |      >>> from scipy.special import ellipk
 |      >>> ellipk(0.8)
 |      2.2572053268208538
 |  
 |  derivative(self, n=1)
 |      Construct a new spline representing the derivative of this spline.
 |      
 |      Parameters
 |      ----------
 |      n : int, optional
 |          Order of derivative to evaluate. Default: 1
 |      
 |      Returns
 |      -------
 |      spline : UnivariateSpline
 |          Spline of order k2=k-n representing the derivative of this
 |          spline.
 |      
 |      See Also
 |      --------
 |      splder, antiderivative
 |      
 |      Notes
 |      -----
 |      
 |      .. versionadded:: 0.13.0
 |      
 |      Examples
 |      --------
 |      This can be used for finding maxima of a curve:
 |      
 |      >>> from scipy.interpolate import UnivariateSpline
 |      >>> x = np.linspace(0, 10, 70)
 |      >>> y = np.sin(x)
 |      >>> spl = UnivariateSpline(x, y, k=4, s=0)
 |      
 |      Now, differentiate the spline and find the zeros of the
 |      derivative. (NB: `sproot` only works for order 3 splines, so we
 |      fit an order 4 spline):
 |      
 |      >>> spl.derivative().roots() / np.pi
 |      array([ 0.50000001,  1.5       ,  2.49999998])
 |      
 |      This agrees well with roots :math:`\pi/2 + n\pi` of
 |      :math:`\cos(x) = \sin'(x)`.
 |  
 |  derivatives(self, x)
 |      Return all derivatives of the spline at the point x.
 |      
 |      Parameters
 |      ----------
 |      x : float
 |          The point to evaluate the derivatives at.
 |      
 |      Returns
 |      -------
 |      der : ndarray, shape(k+1,)
 |          Derivatives of the orders 0 to k.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.interpolate import UnivariateSpline
 |      >>> x = np.linspace(0, 3, 11)
 |      >>> y = x**2
 |      >>> spl = UnivariateSpline(x, y)
 |      >>> spl.derivatives(1.5)
 |      array([2.25, 3.0, 2.0, 0])
 |  
 |  get_coeffs(self)
 |      Return spline coefficients.
 |  
 |  get_knots(self)
 |      Return positions of interior knots of the spline.
 |      
 |      Internally, the knot vector contains ``2*k`` additional boundary knots.
 |  
 |  get_residual(self)
 |      Return weighted sum of squared residuals of the spline approximation.
 |      
 |      This is equivalent to::
 |      
 |           sum((w[i] * (y[i]-spl(x[i])))**2, axis=0)
 |  
 |  integral(self, a, b)
 |      Return definite integral of the spline between two given points.
 |      
 |      Parameters
 |      ----------
 |      a : float
 |          Lower limit of integration.
 |      b : float
 |          Upper limit of integration.
 |      
 |      Returns
 |      -------
 |      integral : float
 |          The value of the definite integral of the spline between limits.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.interpolate import UnivariateSpline
 |      >>> x = np.linspace(0, 3, 11)
 |      >>> y = x**2
 |      >>> spl = UnivariateSpline(x, y)
 |      >>> spl.integral(0, 3)
 |      9.0
 |      
 |      which agrees with :math:`\int x^2 dx = x^3 / 3` between the limits
 |      of 0 and 3.
 |      
 |      A caveat is that this routine assumes the spline to be zero outside of
 |      the data limits:
 |      
 |      >>> spl.integral(-1, 4)
 |      9.0
 |      >>> spl.integral(-1, 0)
 |      0.0
 |  
 |  roots(self)
 |      Return the zeros of the spline.
 |      
 |      Restriction: only cubic splines are supported by fitpack.
 |  
 |  set_smoothing_factor(self, s)
 |      Continue spline computation with the given smoothing
 |      factor s and with the knots found at the last call.
 |      
 |      This routine modifies the spline in place.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from UnivariateSpline:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, x, y, w=None, bbox=[None, None], k=3, ext=0, check_finite=False)',)",scipy,1.1.0,scipy.interpolate.fitpack2.InterpolatedUnivariateSpline,interpolate.fitpack2,InterpolatedUnivariateSpline,"Python Library Documentation: class InterpolatedUnivariateSpline in module scipy.interpolate.fitpack2

class InterpolatedUnivariateSpline(UnivariateSpline)
 |  One-dimensional interpolating spline for a given set of data points.
 |  
 |  Fits a spline y = spl(x) of degree `k` to the provided `x`, `y` data. Spline
 |  function passes through all provided points. Equivalent to
 |  `UnivariateSpline` with  s=0.
 |  
 |  Parameters
 |  ----------
 |  x : (N,) array_like
 |      Input dimension of data points -- must be increasing
 |  y : (N,) array_like
 |      input dimension of data points
 |  w : (N,) array_like, optional
 |      Weights for spline fitting.  Must be positive.  If None (default),
 |      weights are all equal.
 |  bbox : (2,) array_like, optional
 |      2-sequence specifying the boundary of the approximation interval. If
 |      None (default), ``bbox=[x[0], x[-1]]``.
 |  k : int, optional
 |      Degree of the smoothing spline.  Must be 1 <= `k` <= 5.
 |  ext : int or str, optional
 |      Controls the extrapolation mode for elements
 |      not in the interval defined by the knot sequence.
 |  
 |      * if ext=0 or 'extrapolate', return the extrapolated value.
 |      * if ext=1 or 'zeros', return 0
 |      * if ext=2 or 'raise', raise a ValueError
 |      * if ext=3 of 'const', return the boundary value.
 |  
 |      The default value is 0.
 |  
 |  check_finite : bool, optional
 |      Whether to check that the input arrays contain only finite numbers.
 |      Disabling may give a performance gain, but may result in problems
 |      (crashes, non-termination or non-sensical results) if the inputs
 |      do contain infinities or NaNs.
 |      Default is False.
 |  
 |  See Also
 |  --------
 |  UnivariateSpline : Superclass -- allows knots to be selected by a
 |      smoothing condition
 |  LSQUnivariateSpline : spline for which knots are user-selected
 |  splrep : An older, non object-oriented wrapping of FITPACK
 |  splev, sproot, splint, spalde
 |  BivariateSpline : A similar class for two-dimensional spline interpolation
 |  
 |  Notes
 |  -----
 |  The number of data points must be larger than the spline degree `k`.
 |  
 |  Examples
 |  --------
 |  >>> import matplotlib.pyplot as plt
 |  >>> from scipy.interpolate import InterpolatedUnivariateSpline
 |  >>> x = np.linspace(-3, 3, 50)
 |  >>> y = np.exp(-x**2) + 0.1 * np.random.randn(50)
 |  >>> spl = InterpolatedUnivariateSpline(x, y)
 |  >>> plt.plot(x, y, 'ro', ms=5)
 |  >>> xs = np.linspace(-3, 3, 1000)
 |  >>> plt.plot(xs, spl(xs), 'g', lw=3, alpha=0.7)
 |  >>> plt.show()
 |  
 |  Notice that the ``spl(x)`` interpolates `y`:
 |  
 |  >>> spl.get_residual()
 |  0.0
 |  
 |  Method resolution order:
 |      InterpolatedUnivariateSpline
 |      UnivariateSpline
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, x, y, w=None, bbox=[None, None], k=3, ext=0, check_finite=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from UnivariateSpline:
 |  
 |  __call__(self, x, nu=0, ext=None)
 |      Evaluate spline (or its nu-th derivative) at positions x.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          A 1-D array of points at which to return the value of the smoothed
 |          spline or its derivatives. Note: x can be unordered but the
 |          evaluation is more efficient if x is (partially) ordered.
 |      nu  : int
 |          The order of derivative of the spline to compute.
 |      ext : int
 |          Controls the value returned for elements of ``x`` not in the
 |          interval defined by the knot sequence.
 |      
 |          * if ext=0 or 'extrapolate', return the extrapolated value.
 |          * if ext=1 or 'zeros', return 0
 |          * if ext=2 or 'raise', raise a ValueError
 |          * if ext=3 or 'const', return the boundary value.
 |      
 |          The default value is 0, passed from the initialization of
 |          UnivariateSpline.
 |  
 |  antiderivative(self, n=1)
 |      Construct a new spline representing the antiderivative of this spline.
 |      
 |      Parameters
 |      ----------
 |      n : int, optional
 |          Order of antiderivative to evaluate. Default: 1
 |      
 |      Returns
 |      -------
 |      spline : UnivariateSpline
 |          Spline of order k2=k+n representing the antiderivative of this
 |          spline.
 |      
 |      Notes
 |      -----
 |      
 |      .. versionadded:: 0.13.0
 |      
 |      See Also
 |      --------
 |      splantider, derivative
 |      
 |      Examples
 |      --------
 |      >>> from scipy.interpolate import UnivariateSpline
 |      >>> x = np.linspace(0, np.pi/2, 70)
 |      >>> y = 1 / np.sqrt(1 - 0.8*np.sin(x)**2)
 |      >>> spl = UnivariateSpline(x, y, s=0)
 |      
 |      The derivative is the inverse operation of the antiderivative,
 |      although some floating point error accumulates:
 |      
 |      >>> spl(1.7), spl.antiderivative().derivative()(1.7)
 |      (array(2.1565429877197317), array(2.1565429877201865))
 |      
 |      Antiderivative can be used to evaluate definite integrals:
 |      
 |      >>> ispl = spl.antiderivative()
 |      >>> ispl(np.pi/2) - ispl(0)
 |      2.2572053588768486
 |      
 |      This is indeed an approximation to the complete elliptic integral
 |      :math:`K(m) = \int_0^{\pi/2} [1 - m\sin^2 x]^{-1/2} dx`:
 |      
 |      >>> from scipy.special import ellipk
 |      >>> ellipk(0.8)
 |      2.2572053268208538
 |  
 |  derivative(self, n=1)
 |      Construct a new spline representing the derivative of this spline.
 |      
 |      Parameters
 |      ----------
 |      n : int, optional
 |          Order of derivative to evaluate. Default: 1
 |      
 |      Returns
 |      -------
 |      spline : UnivariateSpline
 |          Spline of order k2=k-n representing the derivative of this
 |          spline.
 |      
 |      See Also
 |      --------
 |      splder, antiderivative
 |      
 |      Notes
 |      -----
 |      
 |      .. versionadded:: 0.13.0
 |      
 |      Examples
 |      --------
 |      This can be used for finding maxima of a curve:
 |      
 |      >>> from scipy.interpolate import UnivariateSpline
 |      >>> x = np.linspace(0, 10, 70)
 |      >>> y = np.sin(x)
 |      >>> spl = UnivariateSpline(x, y, k=4, s=0)
 |      
 |      Now, differentiate the spline and find the zeros of the
 |      derivative. (NB: `sproot` only works for order 3 splines, so we
 |      fit an order 4 spline):
 |      
 |      >>> spl.derivative().roots() / np.pi
 |      array([ 0.50000001,  1.5       ,  2.49999998])
 |      
 |      This agrees well with roots :math:`\pi/2 + n\pi` of
 |      :math:`\cos(x) = \sin'(x)`.
 |  
 |  derivatives(self, x)
 |      Return all derivatives of the spline at the point x.
 |      
 |      Parameters
 |      ----------
 |      x : float
 |          The point to evaluate the derivatives at.
 |      
 |      Returns
 |      -------
 |      der : ndarray, shape(k+1,)
 |          Derivatives of the orders 0 to k.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.interpolate import UnivariateSpline
 |      >>> x = np.linspace(0, 3, 11)
 |      >>> y = x**2
 |      >>> spl = UnivariateSpline(x, y)
 |      >>> spl.derivatives(1.5)
 |      array([2.25, 3.0, 2.0, 0])
 |  
 |  get_coeffs(self)
 |      Return spline coefficients.
 |  
 |  get_knots(self)
 |      Return positions of interior knots of the spline.
 |      
 |      Internally, the knot vector contains ``2*k`` additional boundary knots.
 |  
 |  get_residual(self)
 |      Return weighted sum of squared residuals of the spline approximation.
 |      
 |      This is equivalent to::
 |      
 |           sum((w[i] * (y[i]-spl(x[i])))**2, axis=0)
 |  
 |  integral(self, a, b)
 |      Return definite integral of the spline between two given points.
 |      
 |      Parameters
 |      ----------
 |      a : float
 |          Lower limit of integration.
 |      b : float
 |          Upper limit of integration.
 |      
 |      Returns
 |      -------
 |      integral : float
 |          The value of the definite integral of the spline between limits.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.interpolate import UnivariateSpline
 |      >>> x = np.linspace(0, 3, 11)
 |      >>> y = x**2
 |      >>> spl = UnivariateSpline(x, y)
 |      >>> spl.integral(0, 3)
 |      9.0
 |      
 |      which agrees with :math:`\int x^2 dx = x^3 / 3` between the limits
 |      of 0 and 3.
 |      
 |      A caveat is that this routine assumes the spline to be zero outside of
 |      the data limits:
 |      
 |      >>> spl.integral(-1, 4)
 |      9.0
 |      >>> spl.integral(-1, 0)
 |      0.0
 |  
 |  roots(self)
 |      Return the zeros of the spline.
 |      
 |      Restriction: only cubic splines are supported by fitpack.
 |  
 |  set_smoothing_factor(self, s)
 |      Continue spline computation with the given smoothing
 |      factor s and with the knots found at the last call.
 |      
 |      This routine modifies the spline in place.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from UnivariateSpline:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'x', 'y', 'w', 'bbox', 'k', 'ext', 'check_finite')","(nan, nan, nan, None, [None, None], 3, 0, False)","(nan, nan, nan, 'NoneType', 'list', 'int', 'int', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, x, y, w=None, bbox=[None, None], k=3, ext=0, check_finite=False)',)"
scipy,1.1.0,scipy.interpolate.fitpack2.InterpolatedUnivariateSpline._from_tck,interpolate.fitpack2.InterpolatedUnivariateSpline,_from_tck,"Python Library Documentation: method _from_tck in module scipy.interpolate.fitpack2

_from_tck(tck, ext=0) method of builtins.type instance
    Construct a spline object from given tck
",method,"('(tck, ext=0)',)",scipy,1.1.0,scipy.interpolate.fitpack2.InterpolatedUnivariateSpline._from_tck,interpolate.fitpack2.InterpolatedUnivariateSpline,_from_tck,"Python Library Documentation: method _from_tck in module scipy.interpolate.fitpack2

_from_tck(tck, ext=0) method of builtins.type instance
    Construct a spline object from given tck
",method,"('cls', 'tck', 'ext')","(nan, nan, 0)","(nan, nan, 'int')","('arg_info', 'arg_info', 'arg_info')","('(tck, ext=0)',)"
scipy,1.1.0,scipy.interpolate.fitpack2.LSQBivariateSpline,interpolate.fitpack2,LSQBivariateSpline,"Python Library Documentation: class LSQBivariateSpline in module scipy.interpolate.fitpack2

class LSQBivariateSpline(BivariateSpline)
 |  Weighted least-squares bivariate spline approximation.
 |  
 |  Parameters
 |  ----------
 |  x, y, z : array_like
 |      1-D sequences of data points (order is not important).
 |  tx, ty : array_like
 |      Strictly ordered 1-D sequences of knots coordinates.
 |  w : array_like, optional
 |      Positive 1-D array of weights, of the same length as `x`, `y` and `z`.
 |  bbox : (4,) array_like, optional
 |      Sequence of length 4 specifying the boundary of the rectangular
 |      approximation domain.  By default,
 |      ``bbox=[min(x,tx),max(x,tx), min(y,ty),max(y,ty)]``.
 |  kx, ky : ints, optional
 |      Degrees of the bivariate spline. Default is 3.
 |  eps : float, optional
 |      A threshold for determining the effective rank of an over-determined
 |      linear system of equations. `eps` should have a value between 0 and 1,
 |      the default is 1e-16.
 |  
 |  See Also
 |  --------
 |  bisplrep : an older wrapping of FITPACK
 |  bisplev : an older wrapping of FITPACK
 |  UnivariateSpline : a similar class for univariate spline interpolation
 |  SmoothBivariateSpline : create a smoothing BivariateSpline
 |  
 |  Notes
 |  -----
 |  The length of `x`, `y` and `z` should be at least ``(kx+1) * (ky+1)``.
 |  
 |  Method resolution order:
 |      LSQBivariateSpline
 |      BivariateSpline
 |      _BivariateSplineBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, x, y, z, tx, ty, w=None, bbox=[None, None, None, None], kx=3, ky=3, eps=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from BivariateSpline:
 |  
 |  ev(self, xi, yi, dx=0, dy=0)
 |      Evaluate the spline at points
 |      
 |      Returns the interpolated value at ``(xi[i], yi[i]),
 |      i=0,...,len(xi)-1``.
 |      
 |      Parameters
 |      ----------
 |      xi, yi : array_like
 |          Input coordinates. Standard Numpy broadcasting is obeyed.
 |      dx : int, optional
 |          Order of x-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dy : int, optional
 |          Order of y-derivative
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  integral(self, xa, xb, ya, yb)
 |      Evaluate the integral of the spline over area [xa,xb] x [ya,yb].
 |      
 |      Parameters
 |      ----------
 |      xa, xb : float
 |          The end-points of the x integration interval.
 |      ya, yb : float
 |          The end-points of the y integration interval.
 |      
 |      Returns
 |      -------
 |      integ : float
 |          The value of the resulting integral.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BivariateSplineBase:
 |  
 |  __call__(self, x, y, dx=0, dy=0, grid=True)
 |      Evaluate the spline or its derivatives at given positions.
 |      
 |      Parameters
 |      ----------
 |      x, y : array_like
 |          Input coordinates.
 |      
 |          If `grid` is False, evaluate the spline at points ``(x[i],
 |          y[i]), i=0, ..., len(x)-1``.  Standard Numpy broadcasting
 |          is obeyed.
 |      
 |          If `grid` is True: evaluate spline at the grid points
 |          defined by the coordinate arrays x, y. The arrays must be
 |          sorted to increasing order.
 |          
 |          Note that the axis ordering is inverted relative to
 |          the output of meshgrid.
 |      dx : int
 |          Order of x-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dy : int
 |          Order of y-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      grid : bool
 |          Whether to evaluate the results on a grid spanned by the
 |          input arrays, or at points specified by the input arrays.
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  get_coeffs(self)
 |      Return spline coefficients.
 |  
 |  get_knots(self)
 |      Return a tuple (tx,ty) where tx,ty contain knots positions
 |      of the spline with respect to x-, y-variable, respectively.
 |      The position of interior and additional knots are given as
 |      t[k+1:-k-1] and t[:k+1]=b, t[-k-1:]=e, respectively.
 |  
 |  get_residual(self)
 |      Return weighted sum of squared residuals of the spline
 |      approximation: sum ((w[i]*(z[i]-s(x[i],y[i])))**2,axis=0)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BivariateSplineBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, x, y, z, tx, ty, w=None, bbox=[None, None, None, None], kx=3, ky=3, eps=None)',)",scipy,1.1.0,scipy.interpolate.fitpack2.LSQBivariateSpline,interpolate.fitpack2,LSQBivariateSpline,"Python Library Documentation: class LSQBivariateSpline in module scipy.interpolate.fitpack2

class LSQBivariateSpline(BivariateSpline)
 |  Weighted least-squares bivariate spline approximation.
 |  
 |  Parameters
 |  ----------
 |  x, y, z : array_like
 |      1-D sequences of data points (order is not important).
 |  tx, ty : array_like
 |      Strictly ordered 1-D sequences of knots coordinates.
 |  w : array_like, optional
 |      Positive 1-D array of weights, of the same length as `x`, `y` and `z`.
 |  bbox : (4,) array_like, optional
 |      Sequence of length 4 specifying the boundary of the rectangular
 |      approximation domain.  By default,
 |      ``bbox=[min(x,tx),max(x,tx), min(y,ty),max(y,ty)]``.
 |  kx, ky : ints, optional
 |      Degrees of the bivariate spline. Default is 3.
 |  eps : float, optional
 |      A threshold for determining the effective rank of an over-determined
 |      linear system of equations. `eps` should have a value between 0 and 1,
 |      the default is 1e-16.
 |  
 |  See Also
 |  --------
 |  bisplrep : an older wrapping of FITPACK
 |  bisplev : an older wrapping of FITPACK
 |  UnivariateSpline : a similar class for univariate spline interpolation
 |  SmoothBivariateSpline : create a smoothing BivariateSpline
 |  
 |  Notes
 |  -----
 |  The length of `x`, `y` and `z` should be at least ``(kx+1) * (ky+1)``.
 |  
 |  Method resolution order:
 |      LSQBivariateSpline
 |      BivariateSpline
 |      _BivariateSplineBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, x, y, z, tx, ty, w=None, bbox=[None, None, None, None], kx=3, ky=3, eps=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from BivariateSpline:
 |  
 |  ev(self, xi, yi, dx=0, dy=0)
 |      Evaluate the spline at points
 |      
 |      Returns the interpolated value at ``(xi[i], yi[i]),
 |      i=0,...,len(xi)-1``.
 |      
 |      Parameters
 |      ----------
 |      xi, yi : array_like
 |          Input coordinates. Standard Numpy broadcasting is obeyed.
 |      dx : int, optional
 |          Order of x-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dy : int, optional
 |          Order of y-derivative
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  integral(self, xa, xb, ya, yb)
 |      Evaluate the integral of the spline over area [xa,xb] x [ya,yb].
 |      
 |      Parameters
 |      ----------
 |      xa, xb : float
 |          The end-points of the x integration interval.
 |      ya, yb : float
 |          The end-points of the y integration interval.
 |      
 |      Returns
 |      -------
 |      integ : float
 |          The value of the resulting integral.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BivariateSplineBase:
 |  
 |  __call__(self, x, y, dx=0, dy=0, grid=True)
 |      Evaluate the spline or its derivatives at given positions.
 |      
 |      Parameters
 |      ----------
 |      x, y : array_like
 |          Input coordinates.
 |      
 |          If `grid` is False, evaluate the spline at points ``(x[i],
 |          y[i]), i=0, ..., len(x)-1``.  Standard Numpy broadcasting
 |          is obeyed.
 |      
 |          If `grid` is True: evaluate spline at the grid points
 |          defined by the coordinate arrays x, y. The arrays must be
 |          sorted to increasing order.
 |          
 |          Note that the axis ordering is inverted relative to
 |          the output of meshgrid.
 |      dx : int
 |          Order of x-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dy : int
 |          Order of y-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      grid : bool
 |          Whether to evaluate the results on a grid spanned by the
 |          input arrays, or at points specified by the input arrays.
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  get_coeffs(self)
 |      Return spline coefficients.
 |  
 |  get_knots(self)
 |      Return a tuple (tx,ty) where tx,ty contain knots positions
 |      of the spline with respect to x-, y-variable, respectively.
 |      The position of interior and additional knots are given as
 |      t[k+1:-k-1] and t[:k+1]=b, t[-k-1:]=e, respectively.
 |  
 |  get_residual(self)
 |      Return weighted sum of squared residuals of the spline
 |      approximation: sum ((w[i]*(z[i]-s(x[i],y[i])))**2,axis=0)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BivariateSplineBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'x', 'y', 'z', 'tx', 'ty', 'w', 'bbox', 'kx', 'ky', 'eps')","(nan, nan, nan, nan, nan, nan, None, [None, None, None, None], 3, 3, None)","(nan, nan, nan, nan, nan, nan, 'NoneType', 'list', 'int', 'int', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, x, y, z, tx, ty, w=None, bbox=[None, None, None, None], kx=3, ky=3, eps=None)',)"
scipy,1.1.0,scipy.interpolate.fitpack2.LSQBivariateSpline._from_tck,interpolate.fitpack2.LSQBivariateSpline,_from_tck,"Python Library Documentation: method _from_tck in module scipy.interpolate.fitpack2

_from_tck(tck) method of builtins.type instance
    Construct a spline object from given tck and degree
",method,"('(tck)',)",scipy,1.1.0,scipy.interpolate.fitpack2.LSQBivariateSpline._from_tck,interpolate.fitpack2.LSQBivariateSpline,_from_tck,"Python Library Documentation: method _from_tck in module scipy.interpolate.fitpack2

_from_tck(tck) method of builtins.type instance
    Construct a spline object from given tck and degree
",method,"('cls', 'tck')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(tck)',)"
scipy,1.1.0,scipy.interpolate.fitpack2.LSQSphereBivariateSpline,interpolate.fitpack2,LSQSphereBivariateSpline,"Python Library Documentation: class LSQSphereBivariateSpline in module scipy.interpolate.fitpack2

class LSQSphereBivariateSpline(SphereBivariateSpline)
 |  Weighted least-squares bivariate spline approximation in spherical
 |  coordinates.
 |  
 |  .. versionadded:: 0.11.0
 |  
 |  Parameters
 |  ----------
 |  theta, phi, r : array_like
 |      1-D sequences of data points (order is not important). Coordinates
 |      must be given in radians. Theta must lie within the interval (0, pi),
 |      and phi must lie within the interval (0, 2pi).
 |  tt, tp : array_like
 |      Strictly ordered 1-D sequences of knots coordinates.
 |      Coordinates must satisfy ``0 < tt[i] < pi``, ``0 < tp[i] < 2*pi``.
 |  w : array_like, optional
 |      Positive 1-D sequence of weights, of the same length as `theta`, `phi`
 |      and `r`.
 |  eps : float, optional
 |      A threshold for determining the effective rank of an over-determined
 |      linear system of equations. `eps` should have a value between 0 and 1,
 |      the default is 1e-16.
 |  
 |  Notes
 |  -----
 |  For more information, see the FITPACK_ site about this function.
 |  
 |  .. _FITPACK: http://www.netlib.org/dierckx/sphere.f
 |  
 |  Examples
 |  --------
 |  Suppose we have global data on a coarse grid (the input data does not
 |  have to be on a grid):
 |  
 |  >>> theta = np.linspace(0., np.pi, 7)
 |  >>> phi = np.linspace(0., 2*np.pi, 9)
 |  >>> data = np.empty((theta.shape[0], phi.shape[0]))
 |  >>> data[:,0], data[0,:], data[-1,:] = 0., 0., 0.
 |  >>> data[1:-1,1], data[1:-1,-1] = 1., 1.
 |  >>> data[1,1:-1], data[-2,1:-1] = 1., 1.
 |  >>> data[2:-2,2], data[2:-2,-2] = 2., 2.
 |  >>> data[2,2:-2], data[-3,2:-2] = 2., 2.
 |  >>> data[3,3:-2] = 3.
 |  >>> data = np.roll(data, 4, 1)
 |  
 |  We need to set up the interpolator object. Here, we must also specify the
 |  coordinates of the knots to use.
 |  
 |  >>> lats, lons = np.meshgrid(theta, phi)
 |  >>> knotst, knotsp = theta.copy(), phi.copy()
 |  >>> knotst[0] += .0001
 |  >>> knotst[-1] -= .0001
 |  >>> knotsp[0] += .0001
 |  >>> knotsp[-1] -= .0001
 |  >>> from scipy.interpolate import LSQSphereBivariateSpline
 |  >>> lut = LSQSphereBivariateSpline(lats.ravel(), lons.ravel(),
 |  ...                                data.T.ravel(), knotst, knotsp)
 |  
 |  As a first test, we'll see what the algorithm returns when run on the
 |  input coordinates
 |  
 |  >>> data_orig = lut(theta, phi)
 |  
 |  Finally we interpolate the data to a finer grid
 |  
 |  >>> fine_lats = np.linspace(0., np.pi, 70)
 |  >>> fine_lons = np.linspace(0., 2*np.pi, 90)
 |  
 |  >>> data_lsq = lut(fine_lats, fine_lons)
 |  
 |  >>> import matplotlib.pyplot as plt
 |  >>> fig = plt.figure()
 |  >>> ax1 = fig.add_subplot(131)
 |  >>> ax1.imshow(data, interpolation='nearest')
 |  >>> ax2 = fig.add_subplot(132)
 |  >>> ax2.imshow(data_orig, interpolation='nearest')
 |  >>> ax3 = fig.add_subplot(133)
 |  >>> ax3.imshow(data_lsq, interpolation='nearest')
 |  >>> plt.show()
 |  
 |  Method resolution order:
 |      LSQSphereBivariateSpline
 |      SphereBivariateSpline
 |      _BivariateSplineBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, theta, phi, r, tt, tp, w=None, eps=1e-16)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from SphereBivariateSpline:
 |  
 |  __call__(self, theta, phi, dtheta=0, dphi=0, grid=True)
 |      Evaluate the spline or its derivatives at given positions.
 |      
 |      Parameters
 |      ----------
 |      theta, phi : array_like
 |          Input coordinates.
 |      
 |          If `grid` is False, evaluate the spline at points
 |          ``(theta[i], phi[i]), i=0, ..., len(x)-1``.  Standard
 |          Numpy broadcasting is obeyed.
 |      
 |          If `grid` is True: evaluate spline at the grid points
 |          defined by the coordinate arrays theta, phi. The arrays
 |          must be sorted to increasing order.
 |      dtheta : int, optional
 |          Order of theta-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dphi : int
 |          Order of phi-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      grid : bool
 |          Whether to evaluate the results on a grid spanned by the
 |          input arrays, or at points specified by the input arrays.
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  ev(self, theta, phi, dtheta=0, dphi=0)
 |      Evaluate the spline at points
 |      
 |      Returns the interpolated value at ``(theta[i], phi[i]),
 |      i=0,...,len(theta)-1``.
 |      
 |      Parameters
 |      ----------
 |      theta, phi : array_like
 |          Input coordinates. Standard Numpy broadcasting is obeyed.
 |      dtheta : int, optional
 |          Order of theta-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dphi : int, optional
 |          Order of phi-derivative
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BivariateSplineBase:
 |  
 |  get_coeffs(self)
 |      Return spline coefficients.
 |  
 |  get_knots(self)
 |      Return a tuple (tx,ty) where tx,ty contain knots positions
 |      of the spline with respect to x-, y-variable, respectively.
 |      The position of interior and additional knots are given as
 |      t[k+1:-k-1] and t[:k+1]=b, t[-k-1:]=e, respectively.
 |  
 |  get_residual(self)
 |      Return weighted sum of squared residuals of the spline
 |      approximation: sum ((w[i]*(z[i]-s(x[i],y[i])))**2,axis=0)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BivariateSplineBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, theta, phi, r, tt, tp, w=None, eps=1e-16)',)",scipy,1.1.0,scipy.interpolate.fitpack2.LSQSphereBivariateSpline,interpolate.fitpack2,LSQSphereBivariateSpline,"Python Library Documentation: class LSQSphereBivariateSpline in module scipy.interpolate.fitpack2

class LSQSphereBivariateSpline(SphereBivariateSpline)
 |  Weighted least-squares bivariate spline approximation in spherical
 |  coordinates.
 |  
 |  .. versionadded:: 0.11.0
 |  
 |  Parameters
 |  ----------
 |  theta, phi, r : array_like
 |      1-D sequences of data points (order is not important). Coordinates
 |      must be given in radians. Theta must lie within the interval (0, pi),
 |      and phi must lie within the interval (0, 2pi).
 |  tt, tp : array_like
 |      Strictly ordered 1-D sequences of knots coordinates.
 |      Coordinates must satisfy ``0 < tt[i] < pi``, ``0 < tp[i] < 2*pi``.
 |  w : array_like, optional
 |      Positive 1-D sequence of weights, of the same length as `theta`, `phi`
 |      and `r`.
 |  eps : float, optional
 |      A threshold for determining the effective rank of an over-determined
 |      linear system of equations. `eps` should have a value between 0 and 1,
 |      the default is 1e-16.
 |  
 |  Notes
 |  -----
 |  For more information, see the FITPACK_ site about this function.
 |  
 |  .. _FITPACK: http://www.netlib.org/dierckx/sphere.f
 |  
 |  Examples
 |  --------
 |  Suppose we have global data on a coarse grid (the input data does not
 |  have to be on a grid):
 |  
 |  >>> theta = np.linspace(0., np.pi, 7)
 |  >>> phi = np.linspace(0., 2*np.pi, 9)
 |  >>> data = np.empty((theta.shape[0], phi.shape[0]))
 |  >>> data[:,0], data[0,:], data[-1,:] = 0., 0., 0.
 |  >>> data[1:-1,1], data[1:-1,-1] = 1., 1.
 |  >>> data[1,1:-1], data[-2,1:-1] = 1., 1.
 |  >>> data[2:-2,2], data[2:-2,-2] = 2., 2.
 |  >>> data[2,2:-2], data[-3,2:-2] = 2., 2.
 |  >>> data[3,3:-2] = 3.
 |  >>> data = np.roll(data, 4, 1)
 |  
 |  We need to set up the interpolator object. Here, we must also specify the
 |  coordinates of the knots to use.
 |  
 |  >>> lats, lons = np.meshgrid(theta, phi)
 |  >>> knotst, knotsp = theta.copy(), phi.copy()
 |  >>> knotst[0] += .0001
 |  >>> knotst[-1] -= .0001
 |  >>> knotsp[0] += .0001
 |  >>> knotsp[-1] -= .0001
 |  >>> from scipy.interpolate import LSQSphereBivariateSpline
 |  >>> lut = LSQSphereBivariateSpline(lats.ravel(), lons.ravel(),
 |  ...                                data.T.ravel(), knotst, knotsp)
 |  
 |  As a first test, we'll see what the algorithm returns when run on the
 |  input coordinates
 |  
 |  >>> data_orig = lut(theta, phi)
 |  
 |  Finally we interpolate the data to a finer grid
 |  
 |  >>> fine_lats = np.linspace(0., np.pi, 70)
 |  >>> fine_lons = np.linspace(0., 2*np.pi, 90)
 |  
 |  >>> data_lsq = lut(fine_lats, fine_lons)
 |  
 |  >>> import matplotlib.pyplot as plt
 |  >>> fig = plt.figure()
 |  >>> ax1 = fig.add_subplot(131)
 |  >>> ax1.imshow(data, interpolation='nearest')
 |  >>> ax2 = fig.add_subplot(132)
 |  >>> ax2.imshow(data_orig, interpolation='nearest')
 |  >>> ax3 = fig.add_subplot(133)
 |  >>> ax3.imshow(data_lsq, interpolation='nearest')
 |  >>> plt.show()
 |  
 |  Method resolution order:
 |      LSQSphereBivariateSpline
 |      SphereBivariateSpline
 |      _BivariateSplineBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, theta, phi, r, tt, tp, w=None, eps=1e-16)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from SphereBivariateSpline:
 |  
 |  __call__(self, theta, phi, dtheta=0, dphi=0, grid=True)
 |      Evaluate the spline or its derivatives at given positions.
 |      
 |      Parameters
 |      ----------
 |      theta, phi : array_like
 |          Input coordinates.
 |      
 |          If `grid` is False, evaluate the spline at points
 |          ``(theta[i], phi[i]), i=0, ..., len(x)-1``.  Standard
 |          Numpy broadcasting is obeyed.
 |      
 |          If `grid` is True: evaluate spline at the grid points
 |          defined by the coordinate arrays theta, phi. The arrays
 |          must be sorted to increasing order.
 |      dtheta : int, optional
 |          Order of theta-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dphi : int
 |          Order of phi-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      grid : bool
 |          Whether to evaluate the results on a grid spanned by the
 |          input arrays, or at points specified by the input arrays.
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  ev(self, theta, phi, dtheta=0, dphi=0)
 |      Evaluate the spline at points
 |      
 |      Returns the interpolated value at ``(theta[i], phi[i]),
 |      i=0,...,len(theta)-1``.
 |      
 |      Parameters
 |      ----------
 |      theta, phi : array_like
 |          Input coordinates. Standard Numpy broadcasting is obeyed.
 |      dtheta : int, optional
 |          Order of theta-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dphi : int, optional
 |          Order of phi-derivative
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BivariateSplineBase:
 |  
 |  get_coeffs(self)
 |      Return spline coefficients.
 |  
 |  get_knots(self)
 |      Return a tuple (tx,ty) where tx,ty contain knots positions
 |      of the spline with respect to x-, y-variable, respectively.
 |      The position of interior and additional knots are given as
 |      t[k+1:-k-1] and t[:k+1]=b, t[-k-1:]=e, respectively.
 |  
 |  get_residual(self)
 |      Return weighted sum of squared residuals of the spline
 |      approximation: sum ((w[i]*(z[i]-s(x[i],y[i])))**2,axis=0)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BivariateSplineBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'theta', 'phi', 'r', 'tt', 'tp', 'w', 'eps')","(nan, nan, nan, nan, nan, nan, None, 1e-16)","(nan, nan, nan, nan, nan, nan, 'NoneType', 'float')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, theta, phi, r, tt, tp, w=None, eps=1e-16)',)"
scipy,1.1.0,scipy.interpolate.fitpack2.LSQUnivariateSpline,interpolate.fitpack2,LSQUnivariateSpline,"Python Library Documentation: class LSQUnivariateSpline in module scipy.interpolate.fitpack2

class LSQUnivariateSpline(UnivariateSpline)
 |  One-dimensional spline with explicit internal knots.
 |  
 |  Fits a spline y = spl(x) of degree `k` to the provided `x`, `y` data.  `t`
 |  specifies the internal knots of the spline
 |  
 |  Parameters
 |  ----------
 |  x : (N,) array_like
 |      Input dimension of data points -- must be increasing
 |  y : (N,) array_like
 |      Input dimension of data points
 |  t : (M,) array_like
 |      interior knots of the spline.  Must be in ascending order and::
 |  
 |          bbox[0] < t[0] < ... < t[-1] < bbox[-1]
 |  
 |  w : (N,) array_like, optional
 |      weights for spline fitting.  Must be positive.  If None (default),
 |      weights are all equal.
 |  bbox : (2,) array_like, optional
 |      2-sequence specifying the boundary of the approximation interval. If
 |      None (default), ``bbox = [x[0], x[-1]]``.
 |  k : int, optional
 |      Degree of the smoothing spline.  Must be 1 <= `k` <= 5.
 |      Default is k=3, a cubic spline.
 |  ext : int or str, optional
 |      Controls the extrapolation mode for elements
 |      not in the interval defined by the knot sequence.
 |  
 |      * if ext=0 or 'extrapolate', return the extrapolated value.
 |      * if ext=1 or 'zeros', return 0
 |      * if ext=2 or 'raise', raise a ValueError
 |      * if ext=3 of 'const', return the boundary value.
 |  
 |      The default value is 0.
 |  
 |  check_finite : bool, optional
 |      Whether to check that the input arrays contain only finite numbers.
 |      Disabling may give a performance gain, but may result in problems
 |      (crashes, non-termination or non-sensical results) if the inputs
 |      do contain infinities or NaNs.
 |      Default is False.
 |  
 |  Raises
 |  ------
 |  ValueError
 |      If the interior knots do not satisfy the Schoenberg-Whitney conditions
 |  
 |  See Also
 |  --------
 |  UnivariateSpline : Superclass -- knots are specified by setting a
 |      smoothing condition
 |  InterpolatedUnivariateSpline : spline passing through all points
 |  splrep : An older, non object-oriented wrapping of FITPACK
 |  splev, sproot, splint, spalde
 |  BivariateSpline : A similar class for two-dimensional spline interpolation
 |  
 |  Notes
 |  -----
 |  The number of data points must be larger than the spline degree `k`.
 |  
 |  Knots `t` must satisfy the Schoenberg-Whitney conditions,
 |  i.e., there must be a subset of data points ``x[j]`` such that
 |  ``t[j] < x[j] < t[j+k+1]``, for ``j=0, 1,...,n-k-2``.
 |  
 |  Examples
 |  --------
 |  >>> from scipy.interpolate import LSQUnivariateSpline, UnivariateSpline
 |  >>> import matplotlib.pyplot as plt
 |  >>> x = np.linspace(-3, 3, 50)
 |  >>> y = np.exp(-x**2) + 0.1 * np.random.randn(50)
 |  
 |  Fit a smoothing spline with a pre-defined internal knots:
 |  
 |  >>> t = [-1, 0, 1]
 |  >>> spl = LSQUnivariateSpline(x, y, t)
 |  
 |  >>> xs = np.linspace(-3, 3, 1000)
 |  >>> plt.plot(x, y, 'ro', ms=5)
 |  >>> plt.plot(xs, spl(xs), 'g-', lw=3)
 |  >>> plt.show()
 |  
 |  Check the knot vector:
 |  
 |  >>> spl.get_knots()
 |  array([-3., -1., 0., 1., 3.])
 |  
 |  Constructing lsq spline using the knots from another spline:
 |  
 |  >>> x = np.arange(10)
 |  >>> s = UnivariateSpline(x, x, s=0)
 |  >>> s.get_knots()
 |  array([ 0.,  2.,  3.,  4.,  5.,  6.,  7.,  9.])
 |  >>> knt = s.get_knots()
 |  >>> s1 = LSQUnivariateSpline(x, x, knt[1:-1])    # Chop 1st and last knot
 |  >>> s1.get_knots()
 |  array([ 0.,  2.,  3.,  4.,  5.,  6.,  7.,  9.])
 |  
 |  Method resolution order:
 |      LSQUnivariateSpline
 |      UnivariateSpline
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, x, y, t, w=None, bbox=[None, None], k=3, ext=0, check_finite=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from UnivariateSpline:
 |  
 |  __call__(self, x, nu=0, ext=None)
 |      Evaluate spline (or its nu-th derivative) at positions x.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          A 1-D array of points at which to return the value of the smoothed
 |          spline or its derivatives. Note: x can be unordered but the
 |          evaluation is more efficient if x is (partially) ordered.
 |      nu  : int
 |          The order of derivative of the spline to compute.
 |      ext : int
 |          Controls the value returned for elements of ``x`` not in the
 |          interval defined by the knot sequence.
 |      
 |          * if ext=0 or 'extrapolate', return the extrapolated value.
 |          * if ext=1 or 'zeros', return 0
 |          * if ext=2 or 'raise', raise a ValueError
 |          * if ext=3 or 'const', return the boundary value.
 |      
 |          The default value is 0, passed from the initialization of
 |          UnivariateSpline.
 |  
 |  antiderivative(self, n=1)
 |      Construct a new spline representing the antiderivative of this spline.
 |      
 |      Parameters
 |      ----------
 |      n : int, optional
 |          Order of antiderivative to evaluate. Default: 1
 |      
 |      Returns
 |      -------
 |      spline : UnivariateSpline
 |          Spline of order k2=k+n representing the antiderivative of this
 |          spline.
 |      
 |      Notes
 |      -----
 |      
 |      .. versionadded:: 0.13.0
 |      
 |      See Also
 |      --------
 |      splantider, derivative
 |      
 |      Examples
 |      --------
 |      >>> from scipy.interpolate import UnivariateSpline
 |      >>> x = np.linspace(0, np.pi/2, 70)
 |      >>> y = 1 / np.sqrt(1 - 0.8*np.sin(x)**2)
 |      >>> spl = UnivariateSpline(x, y, s=0)
 |      
 |      The derivative is the inverse operation of the antiderivative,
 |      although some floating point error accumulates:
 |      
 |      >>> spl(1.7), spl.antiderivative().derivative()(1.7)
 |      (array(2.1565429877197317), array(2.1565429877201865))
 |      
 |      Antiderivative can be used to evaluate definite integrals:
 |      
 |      >>> ispl = spl.antiderivative()
 |      >>> ispl(np.pi/2) - ispl(0)
 |      2.2572053588768486
 |      
 |      This is indeed an approximation to the complete elliptic integral
 |      :math:`K(m) = \int_0^{\pi/2} [1 - m\sin^2 x]^{-1/2} dx`:
 |      
 |      >>> from scipy.special import ellipk
 |      >>> ellipk(0.8)
 |      2.2572053268208538
 |  
 |  derivative(self, n=1)
 |      Construct a new spline representing the derivative of this spline.
 |      
 |      Parameters
 |      ----------
 |      n : int, optional
 |          Order of derivative to evaluate. Default: 1
 |      
 |      Returns
 |      -------
 |      spline : UnivariateSpline
 |          Spline of order k2=k-n representing the derivative of this
 |          spline.
 |      
 |      See Also
 |      --------
 |      splder, antiderivative
 |      
 |      Notes
 |      -----
 |      
 |      .. versionadded:: 0.13.0
 |      
 |      Examples
 |      --------
 |      This can be used for finding maxima of a curve:
 |      
 |      >>> from scipy.interpolate import UnivariateSpline
 |      >>> x = np.linspace(0, 10, 70)
 |      >>> y = np.sin(x)
 |      >>> spl = UnivariateSpline(x, y, k=4, s=0)
 |      
 |      Now, differentiate the spline and find the zeros of the
 |      derivative. (NB: `sproot` only works for order 3 splines, so we
 |      fit an order 4 spline):
 |      
 |      >>> spl.derivative().roots() / np.pi
 |      array([ 0.50000001,  1.5       ,  2.49999998])
 |      
 |      This agrees well with roots :math:`\pi/2 + n\pi` of
 |      :math:`\cos(x) = \sin'(x)`.
 |  
 |  derivatives(self, x)
 |      Return all derivatives of the spline at the point x.
 |      
 |      Parameters
 |      ----------
 |      x : float
 |          The point to evaluate the derivatives at.
 |      
 |      Returns
 |      -------
 |      der : ndarray, shape(k+1,)
 |          Derivatives of the orders 0 to k.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.interpolate import UnivariateSpline
 |      >>> x = np.linspace(0, 3, 11)
 |      >>> y = x**2
 |      >>> spl = UnivariateSpline(x, y)
 |      >>> spl.derivatives(1.5)
 |      array([2.25, 3.0, 2.0, 0])
 |  
 |  get_coeffs(self)
 |      Return spline coefficients.
 |  
 |  get_knots(self)
 |      Return positions of interior knots of the spline.
 |      
 |      Internally, the knot vector contains ``2*k`` additional boundary knots.
 |  
 |  get_residual(self)
 |      Return weighted sum of squared residuals of the spline approximation.
 |      
 |      This is equivalent to::
 |      
 |           sum((w[i] * (y[i]-spl(x[i])))**2, axis=0)
 |  
 |  integral(self, a, b)
 |      Return definite integral of the spline between two given points.
 |      
 |      Parameters
 |      ----------
 |      a : float
 |          Lower limit of integration.
 |      b : float
 |          Upper limit of integration.
 |      
 |      Returns
 |      -------
 |      integral : float
 |          The value of the definite integral of the spline between limits.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.interpolate import UnivariateSpline
 |      >>> x = np.linspace(0, 3, 11)
 |      >>> y = x**2
 |      >>> spl = UnivariateSpline(x, y)
 |      >>> spl.integral(0, 3)
 |      9.0
 |      
 |      which agrees with :math:`\int x^2 dx = x^3 / 3` between the limits
 |      of 0 and 3.
 |      
 |      A caveat is that this routine assumes the spline to be zero outside of
 |      the data limits:
 |      
 |      >>> spl.integral(-1, 4)
 |      9.0
 |      >>> spl.integral(-1, 0)
 |      0.0
 |  
 |  roots(self)
 |      Return the zeros of the spline.
 |      
 |      Restriction: only cubic splines are supported by fitpack.
 |  
 |  set_smoothing_factor(self, s)
 |      Continue spline computation with the given smoothing
 |      factor s and with the knots found at the last call.
 |      
 |      This routine modifies the spline in place.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from UnivariateSpline:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, x, y, t, w=None, bbox=[None, None], k=3, ext=0, check_finite=False)',)",scipy,1.1.0,scipy.interpolate.fitpack2.LSQUnivariateSpline,interpolate.fitpack2,LSQUnivariateSpline,"Python Library Documentation: class LSQUnivariateSpline in module scipy.interpolate.fitpack2

class LSQUnivariateSpline(UnivariateSpline)
 |  One-dimensional spline with explicit internal knots.
 |  
 |  Fits a spline y = spl(x) of degree `k` to the provided `x`, `y` data.  `t`
 |  specifies the internal knots of the spline
 |  
 |  Parameters
 |  ----------
 |  x : (N,) array_like
 |      Input dimension of data points -- must be increasing
 |  y : (N,) array_like
 |      Input dimension of data points
 |  t : (M,) array_like
 |      interior knots of the spline.  Must be in ascending order and::
 |  
 |          bbox[0] < t[0] < ... < t[-1] < bbox[-1]
 |  
 |  w : (N,) array_like, optional
 |      weights for spline fitting.  Must be positive.  If None (default),
 |      weights are all equal.
 |  bbox : (2,) array_like, optional
 |      2-sequence specifying the boundary of the approximation interval. If
 |      None (default), ``bbox = [x[0], x[-1]]``.
 |  k : int, optional
 |      Degree of the smoothing spline.  Must be 1 <= `k` <= 5.
 |      Default is k=3, a cubic spline.
 |  ext : int or str, optional
 |      Controls the extrapolation mode for elements
 |      not in the interval defined by the knot sequence.
 |  
 |      * if ext=0 or 'extrapolate', return the extrapolated value.
 |      * if ext=1 or 'zeros', return 0
 |      * if ext=2 or 'raise', raise a ValueError
 |      * if ext=3 of 'const', return the boundary value.
 |  
 |      The default value is 0.
 |  
 |  check_finite : bool, optional
 |      Whether to check that the input arrays contain only finite numbers.
 |      Disabling may give a performance gain, but may result in problems
 |      (crashes, non-termination or non-sensical results) if the inputs
 |      do contain infinities or NaNs.
 |      Default is False.
 |  
 |  Raises
 |  ------
 |  ValueError
 |      If the interior knots do not satisfy the Schoenberg-Whitney conditions
 |  
 |  See Also
 |  --------
 |  UnivariateSpline : Superclass -- knots are specified by setting a
 |      smoothing condition
 |  InterpolatedUnivariateSpline : spline passing through all points
 |  splrep : An older, non object-oriented wrapping of FITPACK
 |  splev, sproot, splint, spalde
 |  BivariateSpline : A similar class for two-dimensional spline interpolation
 |  
 |  Notes
 |  -----
 |  The number of data points must be larger than the spline degree `k`.
 |  
 |  Knots `t` must satisfy the Schoenberg-Whitney conditions,
 |  i.e., there must be a subset of data points ``x[j]`` such that
 |  ``t[j] < x[j] < t[j+k+1]``, for ``j=0, 1,...,n-k-2``.
 |  
 |  Examples
 |  --------
 |  >>> from scipy.interpolate import LSQUnivariateSpline, UnivariateSpline
 |  >>> import matplotlib.pyplot as plt
 |  >>> x = np.linspace(-3, 3, 50)
 |  >>> y = np.exp(-x**2) + 0.1 * np.random.randn(50)
 |  
 |  Fit a smoothing spline with a pre-defined internal knots:
 |  
 |  >>> t = [-1, 0, 1]
 |  >>> spl = LSQUnivariateSpline(x, y, t)
 |  
 |  >>> xs = np.linspace(-3, 3, 1000)
 |  >>> plt.plot(x, y, 'ro', ms=5)
 |  >>> plt.plot(xs, spl(xs), 'g-', lw=3)
 |  >>> plt.show()
 |  
 |  Check the knot vector:
 |  
 |  >>> spl.get_knots()
 |  array([-3., -1., 0., 1., 3.])
 |  
 |  Constructing lsq spline using the knots from another spline:
 |  
 |  >>> x = np.arange(10)
 |  >>> s = UnivariateSpline(x, x, s=0)
 |  >>> s.get_knots()
 |  array([ 0.,  2.,  3.,  4.,  5.,  6.,  7.,  9.])
 |  >>> knt = s.get_knots()
 |  >>> s1 = LSQUnivariateSpline(x, x, knt[1:-1])    # Chop 1st and last knot
 |  >>> s1.get_knots()
 |  array([ 0.,  2.,  3.,  4.,  5.,  6.,  7.,  9.])
 |  
 |  Method resolution order:
 |      LSQUnivariateSpline
 |      UnivariateSpline
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, x, y, t, w=None, bbox=[None, None], k=3, ext=0, check_finite=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from UnivariateSpline:
 |  
 |  __call__(self, x, nu=0, ext=None)
 |      Evaluate spline (or its nu-th derivative) at positions x.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          A 1-D array of points at which to return the value of the smoothed
 |          spline or its derivatives. Note: x can be unordered but the
 |          evaluation is more efficient if x is (partially) ordered.
 |      nu  : int
 |          The order of derivative of the spline to compute.
 |      ext : int
 |          Controls the value returned for elements of ``x`` not in the
 |          interval defined by the knot sequence.
 |      
 |          * if ext=0 or 'extrapolate', return the extrapolated value.
 |          * if ext=1 or 'zeros', return 0
 |          * if ext=2 or 'raise', raise a ValueError
 |          * if ext=3 or 'const', return the boundary value.
 |      
 |          The default value is 0, passed from the initialization of
 |          UnivariateSpline.
 |  
 |  antiderivative(self, n=1)
 |      Construct a new spline representing the antiderivative of this spline.
 |      
 |      Parameters
 |      ----------
 |      n : int, optional
 |          Order of antiderivative to evaluate. Default: 1
 |      
 |      Returns
 |      -------
 |      spline : UnivariateSpline
 |          Spline of order k2=k+n representing the antiderivative of this
 |          spline.
 |      
 |      Notes
 |      -----
 |      
 |      .. versionadded:: 0.13.0
 |      
 |      See Also
 |      --------
 |      splantider, derivative
 |      
 |      Examples
 |      --------
 |      >>> from scipy.interpolate import UnivariateSpline
 |      >>> x = np.linspace(0, np.pi/2, 70)
 |      >>> y = 1 / np.sqrt(1 - 0.8*np.sin(x)**2)
 |      >>> spl = UnivariateSpline(x, y, s=0)
 |      
 |      The derivative is the inverse operation of the antiderivative,
 |      although some floating point error accumulates:
 |      
 |      >>> spl(1.7), spl.antiderivative().derivative()(1.7)
 |      (array(2.1565429877197317), array(2.1565429877201865))
 |      
 |      Antiderivative can be used to evaluate definite integrals:
 |      
 |      >>> ispl = spl.antiderivative()
 |      >>> ispl(np.pi/2) - ispl(0)
 |      2.2572053588768486
 |      
 |      This is indeed an approximation to the complete elliptic integral
 |      :math:`K(m) = \int_0^{\pi/2} [1 - m\sin^2 x]^{-1/2} dx`:
 |      
 |      >>> from scipy.special import ellipk
 |      >>> ellipk(0.8)
 |      2.2572053268208538
 |  
 |  derivative(self, n=1)
 |      Construct a new spline representing the derivative of this spline.
 |      
 |      Parameters
 |      ----------
 |      n : int, optional
 |          Order of derivative to evaluate. Default: 1
 |      
 |      Returns
 |      -------
 |      spline : UnivariateSpline
 |          Spline of order k2=k-n representing the derivative of this
 |          spline.
 |      
 |      See Also
 |      --------
 |      splder, antiderivative
 |      
 |      Notes
 |      -----
 |      
 |      .. versionadded:: 0.13.0
 |      
 |      Examples
 |      --------
 |      This can be used for finding maxima of a curve:
 |      
 |      >>> from scipy.interpolate import UnivariateSpline
 |      >>> x = np.linspace(0, 10, 70)
 |      >>> y = np.sin(x)
 |      >>> spl = UnivariateSpline(x, y, k=4, s=0)
 |      
 |      Now, differentiate the spline and find the zeros of the
 |      derivative. (NB: `sproot` only works for order 3 splines, so we
 |      fit an order 4 spline):
 |      
 |      >>> spl.derivative().roots() / np.pi
 |      array([ 0.50000001,  1.5       ,  2.49999998])
 |      
 |      This agrees well with roots :math:`\pi/2 + n\pi` of
 |      :math:`\cos(x) = \sin'(x)`.
 |  
 |  derivatives(self, x)
 |      Return all derivatives of the spline at the point x.
 |      
 |      Parameters
 |      ----------
 |      x : float
 |          The point to evaluate the derivatives at.
 |      
 |      Returns
 |      -------
 |      der : ndarray, shape(k+1,)
 |          Derivatives of the orders 0 to k.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.interpolate import UnivariateSpline
 |      >>> x = np.linspace(0, 3, 11)
 |      >>> y = x**2
 |      >>> spl = UnivariateSpline(x, y)
 |      >>> spl.derivatives(1.5)
 |      array([2.25, 3.0, 2.0, 0])
 |  
 |  get_coeffs(self)
 |      Return spline coefficients.
 |  
 |  get_knots(self)
 |      Return positions of interior knots of the spline.
 |      
 |      Internally, the knot vector contains ``2*k`` additional boundary knots.
 |  
 |  get_residual(self)
 |      Return weighted sum of squared residuals of the spline approximation.
 |      
 |      This is equivalent to::
 |      
 |           sum((w[i] * (y[i]-spl(x[i])))**2, axis=0)
 |  
 |  integral(self, a, b)
 |      Return definite integral of the spline between two given points.
 |      
 |      Parameters
 |      ----------
 |      a : float
 |          Lower limit of integration.
 |      b : float
 |          Upper limit of integration.
 |      
 |      Returns
 |      -------
 |      integral : float
 |          The value of the definite integral of the spline between limits.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.interpolate import UnivariateSpline
 |      >>> x = np.linspace(0, 3, 11)
 |      >>> y = x**2
 |      >>> spl = UnivariateSpline(x, y)
 |      >>> spl.integral(0, 3)
 |      9.0
 |      
 |      which agrees with :math:`\int x^2 dx = x^3 / 3` between the limits
 |      of 0 and 3.
 |      
 |      A caveat is that this routine assumes the spline to be zero outside of
 |      the data limits:
 |      
 |      >>> spl.integral(-1, 4)
 |      9.0
 |      >>> spl.integral(-1, 0)
 |      0.0
 |  
 |  roots(self)
 |      Return the zeros of the spline.
 |      
 |      Restriction: only cubic splines are supported by fitpack.
 |  
 |  set_smoothing_factor(self, s)
 |      Continue spline computation with the given smoothing
 |      factor s and with the knots found at the last call.
 |      
 |      This routine modifies the spline in place.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from UnivariateSpline:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'x', 'y', 't', 'w', 'bbox', 'k', 'ext', 'check_finite')","(nan, nan, nan, nan, None, [None, None], 3, 0, False)","(nan, nan, nan, nan, 'NoneType', 'list', 'int', 'int', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, x, y, t, w=None, bbox=[None, None], k=3, ext=0, check_finite=False)',)"
scipy,1.1.0,scipy.interpolate.fitpack2.LSQUnivariateSpline._from_tck,interpolate.fitpack2.LSQUnivariateSpline,_from_tck,"Python Library Documentation: method _from_tck in module scipy.interpolate.fitpack2

_from_tck(tck, ext=0) method of builtins.type instance
    Construct a spline object from given tck
",method,"('(tck, ext=0)',)",scipy,1.1.0,scipy.interpolate.fitpack2.LSQUnivariateSpline._from_tck,interpolate.fitpack2.LSQUnivariateSpline,_from_tck,"Python Library Documentation: method _from_tck in module scipy.interpolate.fitpack2

_from_tck(tck, ext=0) method of builtins.type instance
    Construct a spline object from given tck
",method,"('cls', 'tck', 'ext')","(nan, nan, 0)","(nan, nan, 'int')","('arg_info', 'arg_info', 'arg_info')","('(tck, ext=0)',)"
scipy,1.1.0,scipy.interpolate.fitpack2.RectBivariateSpline,interpolate.fitpack2,RectBivariateSpline,"Python Library Documentation: class RectBivariateSpline in module scipy.interpolate.fitpack2

class RectBivariateSpline(BivariateSpline)
 |  Bivariate spline approximation over a rectangular mesh.
 |  
 |  Can be used for both smoothing and interpolating data.
 |  
 |  Parameters
 |  ----------
 |  x,y : array_like
 |      1-D arrays of coordinates in strictly ascending order.
 |  z : array_like
 |      2-D array of data with shape (x.size,y.size).
 |  bbox : array_like, optional
 |      Sequence of length 4 specifying the boundary of the rectangular
 |      approximation domain.  By default,
 |      ``bbox=[min(x,tx),max(x,tx), min(y,ty),max(y,ty)]``.
 |  kx, ky : ints, optional
 |      Degrees of the bivariate spline. Default is 3.
 |  s : float, optional
 |      Positive smoothing factor defined for estimation condition:
 |      ``sum((w[i]*(z[i]-s(x[i], y[i])))**2, axis=0) <= s``
 |      Default is ``s=0``, which is for interpolation.
 |  
 |  See Also
 |  --------
 |  SmoothBivariateSpline : a smoothing bivariate spline for scattered data
 |  bisplrep : an older wrapping of FITPACK
 |  bisplev : an older wrapping of FITPACK
 |  UnivariateSpline : a similar class for univariate spline interpolation
 |  
 |  Method resolution order:
 |      RectBivariateSpline
 |      BivariateSpline
 |      _BivariateSplineBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, x, y, z, bbox=[None, None, None, None], kx=3, ky=3, s=0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from BivariateSpline:
 |  
 |  ev(self, xi, yi, dx=0, dy=0)
 |      Evaluate the spline at points
 |      
 |      Returns the interpolated value at ``(xi[i], yi[i]),
 |      i=0,...,len(xi)-1``.
 |      
 |      Parameters
 |      ----------
 |      xi, yi : array_like
 |          Input coordinates. Standard Numpy broadcasting is obeyed.
 |      dx : int, optional
 |          Order of x-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dy : int, optional
 |          Order of y-derivative
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  integral(self, xa, xb, ya, yb)
 |      Evaluate the integral of the spline over area [xa,xb] x [ya,yb].
 |      
 |      Parameters
 |      ----------
 |      xa, xb : float
 |          The end-points of the x integration interval.
 |      ya, yb : float
 |          The end-points of the y integration interval.
 |      
 |      Returns
 |      -------
 |      integ : float
 |          The value of the resulting integral.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BivariateSplineBase:
 |  
 |  __call__(self, x, y, dx=0, dy=0, grid=True)
 |      Evaluate the spline or its derivatives at given positions.
 |      
 |      Parameters
 |      ----------
 |      x, y : array_like
 |          Input coordinates.
 |      
 |          If `grid` is False, evaluate the spline at points ``(x[i],
 |          y[i]), i=0, ..., len(x)-1``.  Standard Numpy broadcasting
 |          is obeyed.
 |      
 |          If `grid` is True: evaluate spline at the grid points
 |          defined by the coordinate arrays x, y. The arrays must be
 |          sorted to increasing order.
 |          
 |          Note that the axis ordering is inverted relative to
 |          the output of meshgrid.
 |      dx : int
 |          Order of x-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dy : int
 |          Order of y-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      grid : bool
 |          Whether to evaluate the results on a grid spanned by the
 |          input arrays, or at points specified by the input arrays.
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  get_coeffs(self)
 |      Return spline coefficients.
 |  
 |  get_knots(self)
 |      Return a tuple (tx,ty) where tx,ty contain knots positions
 |      of the spline with respect to x-, y-variable, respectively.
 |      The position of interior and additional knots are given as
 |      t[k+1:-k-1] and t[:k+1]=b, t[-k-1:]=e, respectively.
 |  
 |  get_residual(self)
 |      Return weighted sum of squared residuals of the spline
 |      approximation: sum ((w[i]*(z[i]-s(x[i],y[i])))**2,axis=0)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BivariateSplineBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, x, y, z, bbox=[None, None, None, None], kx=3, ky=3, s=0)',)",scipy,1.1.0,scipy.interpolate.fitpack2.RectBivariateSpline,interpolate.fitpack2,RectBivariateSpline,"Python Library Documentation: class RectBivariateSpline in module scipy.interpolate.fitpack2

class RectBivariateSpline(BivariateSpline)
 |  Bivariate spline approximation over a rectangular mesh.
 |  
 |  Can be used for both smoothing and interpolating data.
 |  
 |  Parameters
 |  ----------
 |  x,y : array_like
 |      1-D arrays of coordinates in strictly ascending order.
 |  z : array_like
 |      2-D array of data with shape (x.size,y.size).
 |  bbox : array_like, optional
 |      Sequence of length 4 specifying the boundary of the rectangular
 |      approximation domain.  By default,
 |      ``bbox=[min(x,tx),max(x,tx), min(y,ty),max(y,ty)]``.
 |  kx, ky : ints, optional
 |      Degrees of the bivariate spline. Default is 3.
 |  s : float, optional
 |      Positive smoothing factor defined for estimation condition:
 |      ``sum((w[i]*(z[i]-s(x[i], y[i])))**2, axis=0) <= s``
 |      Default is ``s=0``, which is for interpolation.
 |  
 |  See Also
 |  --------
 |  SmoothBivariateSpline : a smoothing bivariate spline for scattered data
 |  bisplrep : an older wrapping of FITPACK
 |  bisplev : an older wrapping of FITPACK
 |  UnivariateSpline : a similar class for univariate spline interpolation
 |  
 |  Method resolution order:
 |      RectBivariateSpline
 |      BivariateSpline
 |      _BivariateSplineBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, x, y, z, bbox=[None, None, None, None], kx=3, ky=3, s=0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from BivariateSpline:
 |  
 |  ev(self, xi, yi, dx=0, dy=0)
 |      Evaluate the spline at points
 |      
 |      Returns the interpolated value at ``(xi[i], yi[i]),
 |      i=0,...,len(xi)-1``.
 |      
 |      Parameters
 |      ----------
 |      xi, yi : array_like
 |          Input coordinates. Standard Numpy broadcasting is obeyed.
 |      dx : int, optional
 |          Order of x-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dy : int, optional
 |          Order of y-derivative
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  integral(self, xa, xb, ya, yb)
 |      Evaluate the integral of the spline over area [xa,xb] x [ya,yb].
 |      
 |      Parameters
 |      ----------
 |      xa, xb : float
 |          The end-points of the x integration interval.
 |      ya, yb : float
 |          The end-points of the y integration interval.
 |      
 |      Returns
 |      -------
 |      integ : float
 |          The value of the resulting integral.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BivariateSplineBase:
 |  
 |  __call__(self, x, y, dx=0, dy=0, grid=True)
 |      Evaluate the spline or its derivatives at given positions.
 |      
 |      Parameters
 |      ----------
 |      x, y : array_like
 |          Input coordinates.
 |      
 |          If `grid` is False, evaluate the spline at points ``(x[i],
 |          y[i]), i=0, ..., len(x)-1``.  Standard Numpy broadcasting
 |          is obeyed.
 |      
 |          If `grid` is True: evaluate spline at the grid points
 |          defined by the coordinate arrays x, y. The arrays must be
 |          sorted to increasing order.
 |          
 |          Note that the axis ordering is inverted relative to
 |          the output of meshgrid.
 |      dx : int
 |          Order of x-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dy : int
 |          Order of y-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      grid : bool
 |          Whether to evaluate the results on a grid spanned by the
 |          input arrays, or at points specified by the input arrays.
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  get_coeffs(self)
 |      Return spline coefficients.
 |  
 |  get_knots(self)
 |      Return a tuple (tx,ty) where tx,ty contain knots positions
 |      of the spline with respect to x-, y-variable, respectively.
 |      The position of interior and additional knots are given as
 |      t[k+1:-k-1] and t[:k+1]=b, t[-k-1:]=e, respectively.
 |  
 |  get_residual(self)
 |      Return weighted sum of squared residuals of the spline
 |      approximation: sum ((w[i]*(z[i]-s(x[i],y[i])))**2,axis=0)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BivariateSplineBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'x', 'y', 'z', 'bbox', 'kx', 'ky', 's')","(nan, nan, nan, nan, [None, None, None, None], 3, 3, 0)","(nan, nan, nan, nan, 'list', 'int', 'int', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, x, y, z, bbox=[None, None, None, None], kx=3, ky=3, s=0)',)"
scipy,1.1.0,scipy.interpolate.fitpack2.RectBivariateSpline._from_tck,interpolate.fitpack2.RectBivariateSpline,_from_tck,"Python Library Documentation: method _from_tck in module scipy.interpolate.fitpack2

_from_tck(tck) method of builtins.type instance
    Construct a spline object from given tck and degree
",method,"('(tck)',)",scipy,1.1.0,scipy.interpolate.fitpack2.RectBivariateSpline._from_tck,interpolate.fitpack2.RectBivariateSpline,_from_tck,"Python Library Documentation: method _from_tck in module scipy.interpolate.fitpack2

_from_tck(tck) method of builtins.type instance
    Construct a spline object from given tck and degree
",method,"('cls', 'tck')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(tck)',)"
scipy,1.1.0,scipy.interpolate.fitpack2.RectSphereBivariateSpline,interpolate.fitpack2,RectSphereBivariateSpline,"Python Library Documentation: class RectSphereBivariateSpline in module scipy.interpolate.fitpack2

class RectSphereBivariateSpline(SphereBivariateSpline)
 |  Bivariate spline approximation over a rectangular mesh on a sphere.
 |  
 |  Can be used for smoothing data.
 |  
 |  .. versionadded:: 0.11.0
 |  
 |  Parameters
 |  ----------
 |  u : array_like
 |      1-D array of latitude coordinates in strictly ascending order.
 |      Coordinates must be given in radians and lie within the interval
 |      (0, pi).
 |  v : array_like
 |      1-D array of longitude coordinates in strictly ascending order.
 |      Coordinates must be given in radians. First element (v[0]) must lie
 |      within the interval [-pi, pi). Last element (v[-1]) must satisfy
 |      v[-1] <= v[0] + 2*pi.
 |  r : array_like
 |      2-D array of data with shape ``(u.size, v.size)``.
 |  s : float, optional
 |      Positive smoothing factor defined for estimation condition
 |      (``s=0`` is for interpolation).
 |  pole_continuity : bool or (bool, bool), optional
 |      Order of continuity at the poles ``u=0`` (``pole_continuity[0]``) and
 |      ``u=pi`` (``pole_continuity[1]``).  The order of continuity at the pole
 |      will be 1 or 0 when this is True or False, respectively.
 |      Defaults to False.
 |  pole_values : float or (float, float), optional
 |      Data values at the poles ``u=0`` and ``u=pi``.  Either the whole
 |      parameter or each individual element can be None.  Defaults to None.
 |  pole_exact : bool or (bool, bool), optional
 |      Data value exactness at the poles ``u=0`` and ``u=pi``.  If True, the
 |      value is considered to be the right function value, and it will be
 |      fitted exactly. If False, the value will be considered to be a data
 |      value just like the other data values.  Defaults to False.
 |  pole_flat : bool or (bool, bool), optional
 |      For the poles at ``u=0`` and ``u=pi``, specify whether or not the
 |      approximation has vanishing derivatives.  Defaults to False.
 |  
 |  See Also
 |  --------
 |  RectBivariateSpline : bivariate spline approximation over a rectangular
 |      mesh
 |  
 |  Notes
 |  -----
 |  Currently, only the smoothing spline approximation (``iopt[0] = 0`` and
 |  ``iopt[0] = 1`` in the FITPACK routine) is supported.  The exact
 |  least-squares spline approximation is not implemented yet.
 |  
 |  When actually performing the interpolation, the requested `v` values must
 |  lie within the same length 2pi interval that the original `v` values were
 |  chosen from.
 |  
 |  For more information, see the FITPACK_ site about this function.
 |  
 |  .. _FITPACK: http://www.netlib.org/dierckx/spgrid.f
 |  
 |  Examples
 |  --------
 |  Suppose we have global data on a coarse grid
 |  
 |  >>> lats = np.linspace(10, 170, 9) * np.pi / 180.
 |  >>> lons = np.linspace(0, 350, 18) * np.pi / 180.
 |  >>> data = np.dot(np.atleast_2d(90. - np.linspace(-80., 80., 18)).T,
 |  ...               np.atleast_2d(180. - np.abs(np.linspace(0., 350., 9)))).T
 |  
 |  We want to interpolate it to a global one-degree grid
 |  
 |  >>> new_lats = np.linspace(1, 180, 180) * np.pi / 180
 |  >>> new_lons = np.linspace(1, 360, 360) * np.pi / 180
 |  >>> new_lats, new_lons = np.meshgrid(new_lats, new_lons)
 |  
 |  We need to set up the interpolator object
 |  
 |  >>> from scipy.interpolate import RectSphereBivariateSpline
 |  >>> lut = RectSphereBivariateSpline(lats, lons, data)
 |  
 |  Finally we interpolate the data.  The `RectSphereBivariateSpline` object
 |  only takes 1-D arrays as input, therefore we need to do some reshaping.
 |  
 |  >>> data_interp = lut.ev(new_lats.ravel(),
 |  ...                      new_lons.ravel()).reshape((360, 180)).T
 |  
 |  Looking at the original and the interpolated data, one can see that the
 |  interpolant reproduces the original data very well:
 |  
 |  >>> import matplotlib.pyplot as plt
 |  >>> fig = plt.figure()
 |  >>> ax1 = fig.add_subplot(211)
 |  >>> ax1.imshow(data, interpolation='nearest')
 |  >>> ax2 = fig.add_subplot(212)
 |  >>> ax2.imshow(data_interp, interpolation='nearest')
 |  >>> plt.show()
 |  
 |  Choosing the optimal value of ``s`` can be a delicate task. Recommended
 |  values for ``s`` depend on the accuracy of the data values.  If the user
 |  has an idea of the statistical errors on the data, she can also find a
 |  proper estimate for ``s``. By assuming that, if she specifies the
 |  right ``s``, the interpolator will use a spline ``f(u,v)`` which exactly
 |  reproduces the function underlying the data, she can evaluate
 |  ``sum((r(i,j)-s(u(i),v(j)))**2)`` to find a good estimate for this ``s``.
 |  For example, if she knows that the statistical errors on her
 |  ``r(i,j)``-values are not greater than 0.1, she may expect that a good
 |  ``s`` should have a value not larger than ``u.size * v.size * (0.1)**2``.
 |  
 |  If nothing is known about the statistical error in ``r(i,j)``, ``s`` must
 |  be determined by trial and error.  The best is then to start with a very
 |  large value of ``s`` (to determine the least-squares polynomial and the
 |  corresponding upper bound ``fp0`` for ``s``) and then to progressively
 |  decrease the value of ``s`` (say by a factor 10 in the beginning, i.e.
 |  ``s = fp0 / 10, fp0 / 100, ...``  and more carefully as the approximation
 |  shows more detail) to obtain closer fits.
 |  
 |  The interpolation results for different values of ``s`` give some insight
 |  into this process:
 |  
 |  >>> fig2 = plt.figure()
 |  >>> s = [3e9, 2e9, 1e9, 1e8]
 |  >>> for ii in range(len(s)):
 |  ...     lut = RectSphereBivariateSpline(lats, lons, data, s=s[ii])
 |  ...     data_interp = lut.ev(new_lats.ravel(),
 |  ...                          new_lons.ravel()).reshape((360, 180)).T
 |  ...     ax = fig2.add_subplot(2, 2, ii+1)
 |  ...     ax.imshow(data_interp, interpolation='nearest')
 |  ...     ax.set_title(""s = %g"" % s[ii])
 |  >>> plt.show()
 |  
 |  Method resolution order:
 |      RectSphereBivariateSpline
 |      SphereBivariateSpline
 |      _BivariateSplineBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, u, v, r, s=0.0, pole_continuity=False, pole_values=None, pole_exact=False, pole_flat=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from SphereBivariateSpline:
 |  
 |  __call__(self, theta, phi, dtheta=0, dphi=0, grid=True)
 |      Evaluate the spline or its derivatives at given positions.
 |      
 |      Parameters
 |      ----------
 |      theta, phi : array_like
 |          Input coordinates.
 |      
 |          If `grid` is False, evaluate the spline at points
 |          ``(theta[i], phi[i]), i=0, ..., len(x)-1``.  Standard
 |          Numpy broadcasting is obeyed.
 |      
 |          If `grid` is True: evaluate spline at the grid points
 |          defined by the coordinate arrays theta, phi. The arrays
 |          must be sorted to increasing order.
 |      dtheta : int, optional
 |          Order of theta-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dphi : int
 |          Order of phi-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      grid : bool
 |          Whether to evaluate the results on a grid spanned by the
 |          input arrays, or at points specified by the input arrays.
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  ev(self, theta, phi, dtheta=0, dphi=0)
 |      Evaluate the spline at points
 |      
 |      Returns the interpolated value at ``(theta[i], phi[i]),
 |      i=0,...,len(theta)-1``.
 |      
 |      Parameters
 |      ----------
 |      theta, phi : array_like
 |          Input coordinates. Standard Numpy broadcasting is obeyed.
 |      dtheta : int, optional
 |          Order of theta-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dphi : int, optional
 |          Order of phi-derivative
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BivariateSplineBase:
 |  
 |  get_coeffs(self)
 |      Return spline coefficients.
 |  
 |  get_knots(self)
 |      Return a tuple (tx,ty) where tx,ty contain knots positions
 |      of the spline with respect to x-, y-variable, respectively.
 |      The position of interior and additional knots are given as
 |      t[k+1:-k-1] and t[:k+1]=b, t[-k-1:]=e, respectively.
 |  
 |  get_residual(self)
 |      Return weighted sum of squared residuals of the spline
 |      approximation: sum ((w[i]*(z[i]-s(x[i],y[i])))**2,axis=0)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BivariateSplineBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, u, v, r, s=0.0, pole_continuity=False, pole_values=None, pole_exact=False, pole_flat=False)',)",scipy,1.1.0,scipy.interpolate.fitpack2.RectSphereBivariateSpline,interpolate.fitpack2,RectSphereBivariateSpline,"Python Library Documentation: class RectSphereBivariateSpline in module scipy.interpolate.fitpack2

class RectSphereBivariateSpline(SphereBivariateSpline)
 |  Bivariate spline approximation over a rectangular mesh on a sphere.
 |  
 |  Can be used for smoothing data.
 |  
 |  .. versionadded:: 0.11.0
 |  
 |  Parameters
 |  ----------
 |  u : array_like
 |      1-D array of latitude coordinates in strictly ascending order.
 |      Coordinates must be given in radians and lie within the interval
 |      (0, pi).
 |  v : array_like
 |      1-D array of longitude coordinates in strictly ascending order.
 |      Coordinates must be given in radians. First element (v[0]) must lie
 |      within the interval [-pi, pi). Last element (v[-1]) must satisfy
 |      v[-1] <= v[0] + 2*pi.
 |  r : array_like
 |      2-D array of data with shape ``(u.size, v.size)``.
 |  s : float, optional
 |      Positive smoothing factor defined for estimation condition
 |      (``s=0`` is for interpolation).
 |  pole_continuity : bool or (bool, bool), optional
 |      Order of continuity at the poles ``u=0`` (``pole_continuity[0]``) and
 |      ``u=pi`` (``pole_continuity[1]``).  The order of continuity at the pole
 |      will be 1 or 0 when this is True or False, respectively.
 |      Defaults to False.
 |  pole_values : float or (float, float), optional
 |      Data values at the poles ``u=0`` and ``u=pi``.  Either the whole
 |      parameter or each individual element can be None.  Defaults to None.
 |  pole_exact : bool or (bool, bool), optional
 |      Data value exactness at the poles ``u=0`` and ``u=pi``.  If True, the
 |      value is considered to be the right function value, and it will be
 |      fitted exactly. If False, the value will be considered to be a data
 |      value just like the other data values.  Defaults to False.
 |  pole_flat : bool or (bool, bool), optional
 |      For the poles at ``u=0`` and ``u=pi``, specify whether or not the
 |      approximation has vanishing derivatives.  Defaults to False.
 |  
 |  See Also
 |  --------
 |  RectBivariateSpline : bivariate spline approximation over a rectangular
 |      mesh
 |  
 |  Notes
 |  -----
 |  Currently, only the smoothing spline approximation (``iopt[0] = 0`` and
 |  ``iopt[0] = 1`` in the FITPACK routine) is supported.  The exact
 |  least-squares spline approximation is not implemented yet.
 |  
 |  When actually performing the interpolation, the requested `v` values must
 |  lie within the same length 2pi interval that the original `v` values were
 |  chosen from.
 |  
 |  For more information, see the FITPACK_ site about this function.
 |  
 |  .. _FITPACK: http://www.netlib.org/dierckx/spgrid.f
 |  
 |  Examples
 |  --------
 |  Suppose we have global data on a coarse grid
 |  
 |  >>> lats = np.linspace(10, 170, 9) * np.pi / 180.
 |  >>> lons = np.linspace(0, 350, 18) * np.pi / 180.
 |  >>> data = np.dot(np.atleast_2d(90. - np.linspace(-80., 80., 18)).T,
 |  ...               np.atleast_2d(180. - np.abs(np.linspace(0., 350., 9)))).T
 |  
 |  We want to interpolate it to a global one-degree grid
 |  
 |  >>> new_lats = np.linspace(1, 180, 180) * np.pi / 180
 |  >>> new_lons = np.linspace(1, 360, 360) * np.pi / 180
 |  >>> new_lats, new_lons = np.meshgrid(new_lats, new_lons)
 |  
 |  We need to set up the interpolator object
 |  
 |  >>> from scipy.interpolate import RectSphereBivariateSpline
 |  >>> lut = RectSphereBivariateSpline(lats, lons, data)
 |  
 |  Finally we interpolate the data.  The `RectSphereBivariateSpline` object
 |  only takes 1-D arrays as input, therefore we need to do some reshaping.
 |  
 |  >>> data_interp = lut.ev(new_lats.ravel(),
 |  ...                      new_lons.ravel()).reshape((360, 180)).T
 |  
 |  Looking at the original and the interpolated data, one can see that the
 |  interpolant reproduces the original data very well:
 |  
 |  >>> import matplotlib.pyplot as plt
 |  >>> fig = plt.figure()
 |  >>> ax1 = fig.add_subplot(211)
 |  >>> ax1.imshow(data, interpolation='nearest')
 |  >>> ax2 = fig.add_subplot(212)
 |  >>> ax2.imshow(data_interp, interpolation='nearest')
 |  >>> plt.show()
 |  
 |  Choosing the optimal value of ``s`` can be a delicate task. Recommended
 |  values for ``s`` depend on the accuracy of the data values.  If the user
 |  has an idea of the statistical errors on the data, she can also find a
 |  proper estimate for ``s``. By assuming that, if she specifies the
 |  right ``s``, the interpolator will use a spline ``f(u,v)`` which exactly
 |  reproduces the function underlying the data, she can evaluate
 |  ``sum((r(i,j)-s(u(i),v(j)))**2)`` to find a good estimate for this ``s``.
 |  For example, if she knows that the statistical errors on her
 |  ``r(i,j)``-values are not greater than 0.1, she may expect that a good
 |  ``s`` should have a value not larger than ``u.size * v.size * (0.1)**2``.
 |  
 |  If nothing is known about the statistical error in ``r(i,j)``, ``s`` must
 |  be determined by trial and error.  The best is then to start with a very
 |  large value of ``s`` (to determine the least-squares polynomial and the
 |  corresponding upper bound ``fp0`` for ``s``) and then to progressively
 |  decrease the value of ``s`` (say by a factor 10 in the beginning, i.e.
 |  ``s = fp0 / 10, fp0 / 100, ...``  and more carefully as the approximation
 |  shows more detail) to obtain closer fits.
 |  
 |  The interpolation results for different values of ``s`` give some insight
 |  into this process:
 |  
 |  >>> fig2 = plt.figure()
 |  >>> s = [3e9, 2e9, 1e9, 1e8]
 |  >>> for ii in range(len(s)):
 |  ...     lut = RectSphereBivariateSpline(lats, lons, data, s=s[ii])
 |  ...     data_interp = lut.ev(new_lats.ravel(),
 |  ...                          new_lons.ravel()).reshape((360, 180)).T
 |  ...     ax = fig2.add_subplot(2, 2, ii+1)
 |  ...     ax.imshow(data_interp, interpolation='nearest')
 |  ...     ax.set_title(""s = %g"" % s[ii])
 |  >>> plt.show()
 |  
 |  Method resolution order:
 |      RectSphereBivariateSpline
 |      SphereBivariateSpline
 |      _BivariateSplineBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, u, v, r, s=0.0, pole_continuity=False, pole_values=None, pole_exact=False, pole_flat=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from SphereBivariateSpline:
 |  
 |  __call__(self, theta, phi, dtheta=0, dphi=0, grid=True)
 |      Evaluate the spline or its derivatives at given positions.
 |      
 |      Parameters
 |      ----------
 |      theta, phi : array_like
 |          Input coordinates.
 |      
 |          If `grid` is False, evaluate the spline at points
 |          ``(theta[i], phi[i]), i=0, ..., len(x)-1``.  Standard
 |          Numpy broadcasting is obeyed.
 |      
 |          If `grid` is True: evaluate spline at the grid points
 |          defined by the coordinate arrays theta, phi. The arrays
 |          must be sorted to increasing order.
 |      dtheta : int, optional
 |          Order of theta-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dphi : int
 |          Order of phi-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      grid : bool
 |          Whether to evaluate the results on a grid spanned by the
 |          input arrays, or at points specified by the input arrays.
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  ev(self, theta, phi, dtheta=0, dphi=0)
 |      Evaluate the spline at points
 |      
 |      Returns the interpolated value at ``(theta[i], phi[i]),
 |      i=0,...,len(theta)-1``.
 |      
 |      Parameters
 |      ----------
 |      theta, phi : array_like
 |          Input coordinates. Standard Numpy broadcasting is obeyed.
 |      dtheta : int, optional
 |          Order of theta-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dphi : int, optional
 |          Order of phi-derivative
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BivariateSplineBase:
 |  
 |  get_coeffs(self)
 |      Return spline coefficients.
 |  
 |  get_knots(self)
 |      Return a tuple (tx,ty) where tx,ty contain knots positions
 |      of the spline with respect to x-, y-variable, respectively.
 |      The position of interior and additional knots are given as
 |      t[k+1:-k-1] and t[:k+1]=b, t[-k-1:]=e, respectively.
 |  
 |  get_residual(self)
 |      Return weighted sum of squared residuals of the spline
 |      approximation: sum ((w[i]*(z[i]-s(x[i],y[i])))**2,axis=0)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BivariateSplineBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'u', 'v', 'r', 's', 'pole_continuity', 'pole_values', 'pole_exact', 'pole_flat')","(nan, nan, nan, nan, 0.0, False, None, False, False)","(nan, nan, nan, nan, 'float', 'bool', 'NoneType', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, u, v, r, s=0.0, pole_continuity=False, pole_values=None, pole_exact=False, pole_flat=False)',)"
scipy,1.1.0,scipy.interpolate.fitpack2.SmoothBivariateSpline,interpolate.fitpack2,SmoothBivariateSpline,"Python Library Documentation: class SmoothBivariateSpline in module scipy.interpolate.fitpack2

class SmoothBivariateSpline(BivariateSpline)
 |  Smooth bivariate spline approximation.
 |  
 |  Parameters
 |  ----------
 |  x, y, z : array_like
 |      1-D sequences of data points (order is not important).
 |  w : array_like, optional
 |      Positive 1-D sequence of weights, of same length as `x`, `y` and `z`.
 |  bbox : array_like, optional
 |      Sequence of length 4 specifying the boundary of the rectangular
 |      approximation domain.  By default,
 |      ``bbox=[min(x,tx),max(x,tx), min(y,ty),max(y,ty)]``.
 |  kx, ky : ints, optional
 |      Degrees of the bivariate spline. Default is 3.
 |  s : float, optional
 |      Positive smoothing factor defined for estimation condition:
 |      ``sum((w[i]*(z[i]-s(x[i], y[i])))**2, axis=0) <= s``
 |      Default ``s=len(w)`` which should be a good value if ``1/w[i]`` is an
 |      estimate of the standard deviation of ``z[i]``.
 |  eps : float, optional
 |      A threshold for determining the effective rank of an over-determined
 |      linear system of equations. `eps` should have a value between 0 and 1,
 |      the default is 1e-16.
 |  
 |  See Also
 |  --------
 |  bisplrep : an older wrapping of FITPACK
 |  bisplev : an older wrapping of FITPACK
 |  UnivariateSpline : a similar class for univariate spline interpolation
 |  LSQUnivariateSpline : to create a BivariateSpline using weighted
 |  
 |  Notes
 |  -----
 |  The length of `x`, `y` and `z` should be at least ``(kx+1) * (ky+1)``.
 |  
 |  Method resolution order:
 |      SmoothBivariateSpline
 |      BivariateSpline
 |      _BivariateSplineBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, x, y, z, w=None, bbox=[None, None, None, None], kx=3, ky=3, s=None, eps=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from BivariateSpline:
 |  
 |  ev(self, xi, yi, dx=0, dy=0)
 |      Evaluate the spline at points
 |      
 |      Returns the interpolated value at ``(xi[i], yi[i]),
 |      i=0,...,len(xi)-1``.
 |      
 |      Parameters
 |      ----------
 |      xi, yi : array_like
 |          Input coordinates. Standard Numpy broadcasting is obeyed.
 |      dx : int, optional
 |          Order of x-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dy : int, optional
 |          Order of y-derivative
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  integral(self, xa, xb, ya, yb)
 |      Evaluate the integral of the spline over area [xa,xb] x [ya,yb].
 |      
 |      Parameters
 |      ----------
 |      xa, xb : float
 |          The end-points of the x integration interval.
 |      ya, yb : float
 |          The end-points of the y integration interval.
 |      
 |      Returns
 |      -------
 |      integ : float
 |          The value of the resulting integral.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BivariateSplineBase:
 |  
 |  __call__(self, x, y, dx=0, dy=0, grid=True)
 |      Evaluate the spline or its derivatives at given positions.
 |      
 |      Parameters
 |      ----------
 |      x, y : array_like
 |          Input coordinates.
 |      
 |          If `grid` is False, evaluate the spline at points ``(x[i],
 |          y[i]), i=0, ..., len(x)-1``.  Standard Numpy broadcasting
 |          is obeyed.
 |      
 |          If `grid` is True: evaluate spline at the grid points
 |          defined by the coordinate arrays x, y. The arrays must be
 |          sorted to increasing order.
 |          
 |          Note that the axis ordering is inverted relative to
 |          the output of meshgrid.
 |      dx : int
 |          Order of x-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dy : int
 |          Order of y-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      grid : bool
 |          Whether to evaluate the results on a grid spanned by the
 |          input arrays, or at points specified by the input arrays.
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  get_coeffs(self)
 |      Return spline coefficients.
 |  
 |  get_knots(self)
 |      Return a tuple (tx,ty) where tx,ty contain knots positions
 |      of the spline with respect to x-, y-variable, respectively.
 |      The position of interior and additional knots are given as
 |      t[k+1:-k-1] and t[:k+1]=b, t[-k-1:]=e, respectively.
 |  
 |  get_residual(self)
 |      Return weighted sum of squared residuals of the spline
 |      approximation: sum ((w[i]*(z[i]-s(x[i],y[i])))**2,axis=0)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BivariateSplineBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, x, y, z, w=None, bbox=[None, None, None, None], kx=3, ky=3, s=None, eps=None)',)",scipy,1.1.0,scipy.interpolate.fitpack2.SmoothBivariateSpline,interpolate.fitpack2,SmoothBivariateSpline,"Python Library Documentation: class SmoothBivariateSpline in module scipy.interpolate.fitpack2

class SmoothBivariateSpline(BivariateSpline)
 |  Smooth bivariate spline approximation.
 |  
 |  Parameters
 |  ----------
 |  x, y, z : array_like
 |      1-D sequences of data points (order is not important).
 |  w : array_like, optional
 |      Positive 1-D sequence of weights, of same length as `x`, `y` and `z`.
 |  bbox : array_like, optional
 |      Sequence of length 4 specifying the boundary of the rectangular
 |      approximation domain.  By default,
 |      ``bbox=[min(x,tx),max(x,tx), min(y,ty),max(y,ty)]``.
 |  kx, ky : ints, optional
 |      Degrees of the bivariate spline. Default is 3.
 |  s : float, optional
 |      Positive smoothing factor defined for estimation condition:
 |      ``sum((w[i]*(z[i]-s(x[i], y[i])))**2, axis=0) <= s``
 |      Default ``s=len(w)`` which should be a good value if ``1/w[i]`` is an
 |      estimate of the standard deviation of ``z[i]``.
 |  eps : float, optional
 |      A threshold for determining the effective rank of an over-determined
 |      linear system of equations. `eps` should have a value between 0 and 1,
 |      the default is 1e-16.
 |  
 |  See Also
 |  --------
 |  bisplrep : an older wrapping of FITPACK
 |  bisplev : an older wrapping of FITPACK
 |  UnivariateSpline : a similar class for univariate spline interpolation
 |  LSQUnivariateSpline : to create a BivariateSpline using weighted
 |  
 |  Notes
 |  -----
 |  The length of `x`, `y` and `z` should be at least ``(kx+1) * (ky+1)``.
 |  
 |  Method resolution order:
 |      SmoothBivariateSpline
 |      BivariateSpline
 |      _BivariateSplineBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, x, y, z, w=None, bbox=[None, None, None, None], kx=3, ky=3, s=None, eps=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from BivariateSpline:
 |  
 |  ev(self, xi, yi, dx=0, dy=0)
 |      Evaluate the spline at points
 |      
 |      Returns the interpolated value at ``(xi[i], yi[i]),
 |      i=0,...,len(xi)-1``.
 |      
 |      Parameters
 |      ----------
 |      xi, yi : array_like
 |          Input coordinates. Standard Numpy broadcasting is obeyed.
 |      dx : int, optional
 |          Order of x-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dy : int, optional
 |          Order of y-derivative
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  integral(self, xa, xb, ya, yb)
 |      Evaluate the integral of the spline over area [xa,xb] x [ya,yb].
 |      
 |      Parameters
 |      ----------
 |      xa, xb : float
 |          The end-points of the x integration interval.
 |      ya, yb : float
 |          The end-points of the y integration interval.
 |      
 |      Returns
 |      -------
 |      integ : float
 |          The value of the resulting integral.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BivariateSplineBase:
 |  
 |  __call__(self, x, y, dx=0, dy=0, grid=True)
 |      Evaluate the spline or its derivatives at given positions.
 |      
 |      Parameters
 |      ----------
 |      x, y : array_like
 |          Input coordinates.
 |      
 |          If `grid` is False, evaluate the spline at points ``(x[i],
 |          y[i]), i=0, ..., len(x)-1``.  Standard Numpy broadcasting
 |          is obeyed.
 |      
 |          If `grid` is True: evaluate spline at the grid points
 |          defined by the coordinate arrays x, y. The arrays must be
 |          sorted to increasing order.
 |          
 |          Note that the axis ordering is inverted relative to
 |          the output of meshgrid.
 |      dx : int
 |          Order of x-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dy : int
 |          Order of y-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      grid : bool
 |          Whether to evaluate the results on a grid spanned by the
 |          input arrays, or at points specified by the input arrays.
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  get_coeffs(self)
 |      Return spline coefficients.
 |  
 |  get_knots(self)
 |      Return a tuple (tx,ty) where tx,ty contain knots positions
 |      of the spline with respect to x-, y-variable, respectively.
 |      The position of interior and additional knots are given as
 |      t[k+1:-k-1] and t[:k+1]=b, t[-k-1:]=e, respectively.
 |  
 |  get_residual(self)
 |      Return weighted sum of squared residuals of the spline
 |      approximation: sum ((w[i]*(z[i]-s(x[i],y[i])))**2,axis=0)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BivariateSplineBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'x', 'y', 'z', 'w', 'bbox', 'kx', 'ky', 's', 'eps')","(nan, nan, nan, nan, None, [None, None, None, None], 3, 3, None, None)","(nan, nan, nan, nan, 'NoneType', 'list', 'int', 'int', 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, x, y, z, w=None, bbox=[None, None, None, None], kx=3, ky=3, s=None, eps=None)',)"
scipy,1.1.0,scipy.interpolate.fitpack2.SmoothBivariateSpline._from_tck,interpolate.fitpack2.SmoothBivariateSpline,_from_tck,"Python Library Documentation: method _from_tck in module scipy.interpolate.fitpack2

_from_tck(tck) method of builtins.type instance
    Construct a spline object from given tck and degree
",method,"('(tck)',)",scipy,1.1.0,scipy.interpolate.fitpack2.SmoothBivariateSpline._from_tck,interpolate.fitpack2.SmoothBivariateSpline,_from_tck,"Python Library Documentation: method _from_tck in module scipy.interpolate.fitpack2

_from_tck(tck) method of builtins.type instance
    Construct a spline object from given tck and degree
",method,"('cls', 'tck')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(tck)',)"
scipy,1.1.0,scipy.interpolate.fitpack2.SmoothSphereBivariateSpline,interpolate.fitpack2,SmoothSphereBivariateSpline,"Python Library Documentation: class SmoothSphereBivariateSpline in module scipy.interpolate.fitpack2

class SmoothSphereBivariateSpline(SphereBivariateSpline)
 |  Smooth bivariate spline approximation in spherical coordinates.
 |  
 |  .. versionadded:: 0.11.0
 |  
 |  Parameters
 |  ----------
 |  theta, phi, r : array_like
 |      1-D sequences of data points (order is not important). Coordinates
 |      must be given in radians. Theta must lie within the interval (0, pi),
 |      and phi must lie within the interval (0, 2pi).
 |  w : array_like, optional
 |      Positive 1-D sequence of weights.
 |  s : float, optional
 |      Positive smoothing factor defined for estimation condition:
 |      ``sum((w(i)*(r(i) - s(theta(i), phi(i))))**2, axis=0) <= s``
 |      Default ``s=len(w)`` which should be a good value if 1/w[i] is an
 |      estimate of the standard deviation of r[i].
 |  eps : float, optional
 |      A threshold for determining the effective rank of an over-determined
 |      linear system of equations. `eps` should have a value between 0 and 1,
 |      the default is 1e-16.
 |  
 |  Notes
 |  -----
 |  For more information, see the FITPACK_ site about this function.
 |  
 |  .. _FITPACK: http://www.netlib.org/dierckx/sphere.f
 |  
 |  Examples
 |  --------
 |  Suppose we have global data on a coarse grid (the input data does not
 |  have to be on a grid):
 |  
 |  >>> theta = np.linspace(0., np.pi, 7)
 |  >>> phi = np.linspace(0., 2*np.pi, 9)
 |  >>> data = np.empty((theta.shape[0], phi.shape[0]))
 |  >>> data[:,0], data[0,:], data[-1,:] = 0., 0., 0.
 |  >>> data[1:-1,1], data[1:-1,-1] = 1., 1.
 |  >>> data[1,1:-1], data[-2,1:-1] = 1., 1.
 |  >>> data[2:-2,2], data[2:-2,-2] = 2., 2.
 |  >>> data[2,2:-2], data[-3,2:-2] = 2., 2.
 |  >>> data[3,3:-2] = 3.
 |  >>> data = np.roll(data, 4, 1)
 |  
 |  We need to set up the interpolator object
 |  
 |  >>> lats, lons = np.meshgrid(theta, phi)
 |  >>> from scipy.interpolate import SmoothSphereBivariateSpline
 |  >>> lut = SmoothSphereBivariateSpline(lats.ravel(), lons.ravel(),
 |  ...                                   data.T.ravel(), s=3.5)
 |  
 |  As a first test, we'll see what the algorithm returns when run on the
 |  input coordinates
 |  
 |  >>> data_orig = lut(theta, phi)
 |  
 |  Finally we interpolate the data to a finer grid
 |  
 |  >>> fine_lats = np.linspace(0., np.pi, 70)
 |  >>> fine_lons = np.linspace(0., 2 * np.pi, 90)
 |  
 |  >>> data_smth = lut(fine_lats, fine_lons)
 |  
 |  >>> import matplotlib.pyplot as plt
 |  >>> fig = plt.figure()
 |  >>> ax1 = fig.add_subplot(131)
 |  >>> ax1.imshow(data, interpolation='nearest')
 |  >>> ax2 = fig.add_subplot(132)
 |  >>> ax2.imshow(data_orig, interpolation='nearest')
 |  >>> ax3 = fig.add_subplot(133)
 |  >>> ax3.imshow(data_smth, interpolation='nearest')
 |  >>> plt.show()
 |  
 |  Method resolution order:
 |      SmoothSphereBivariateSpline
 |      SphereBivariateSpline
 |      _BivariateSplineBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, theta, phi, r, w=None, s=0.0, eps=1e-16)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from SphereBivariateSpline:
 |  
 |  __call__(self, theta, phi, dtheta=0, dphi=0, grid=True)
 |      Evaluate the spline or its derivatives at given positions.
 |      
 |      Parameters
 |      ----------
 |      theta, phi : array_like
 |          Input coordinates.
 |      
 |          If `grid` is False, evaluate the spline at points
 |          ``(theta[i], phi[i]), i=0, ..., len(x)-1``.  Standard
 |          Numpy broadcasting is obeyed.
 |      
 |          If `grid` is True: evaluate spline at the grid points
 |          defined by the coordinate arrays theta, phi. The arrays
 |          must be sorted to increasing order.
 |      dtheta : int, optional
 |          Order of theta-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dphi : int
 |          Order of phi-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      grid : bool
 |          Whether to evaluate the results on a grid spanned by the
 |          input arrays, or at points specified by the input arrays.
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  ev(self, theta, phi, dtheta=0, dphi=0)
 |      Evaluate the spline at points
 |      
 |      Returns the interpolated value at ``(theta[i], phi[i]),
 |      i=0,...,len(theta)-1``.
 |      
 |      Parameters
 |      ----------
 |      theta, phi : array_like
 |          Input coordinates. Standard Numpy broadcasting is obeyed.
 |      dtheta : int, optional
 |          Order of theta-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dphi : int, optional
 |          Order of phi-derivative
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BivariateSplineBase:
 |  
 |  get_coeffs(self)
 |      Return spline coefficients.
 |  
 |  get_knots(self)
 |      Return a tuple (tx,ty) where tx,ty contain knots positions
 |      of the spline with respect to x-, y-variable, respectively.
 |      The position of interior and additional knots are given as
 |      t[k+1:-k-1] and t[:k+1]=b, t[-k-1:]=e, respectively.
 |  
 |  get_residual(self)
 |      Return weighted sum of squared residuals of the spline
 |      approximation: sum ((w[i]*(z[i]-s(x[i],y[i])))**2,axis=0)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BivariateSplineBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, theta, phi, r, w=None, s=0.0, eps=1e-16)',)",scipy,1.1.0,scipy.interpolate.fitpack2.SmoothSphereBivariateSpline,interpolate.fitpack2,SmoothSphereBivariateSpline,"Python Library Documentation: class SmoothSphereBivariateSpline in module scipy.interpolate.fitpack2

class SmoothSphereBivariateSpline(SphereBivariateSpline)
 |  Smooth bivariate spline approximation in spherical coordinates.
 |  
 |  .. versionadded:: 0.11.0
 |  
 |  Parameters
 |  ----------
 |  theta, phi, r : array_like
 |      1-D sequences of data points (order is not important). Coordinates
 |      must be given in radians. Theta must lie within the interval (0, pi),
 |      and phi must lie within the interval (0, 2pi).
 |  w : array_like, optional
 |      Positive 1-D sequence of weights.
 |  s : float, optional
 |      Positive smoothing factor defined for estimation condition:
 |      ``sum((w(i)*(r(i) - s(theta(i), phi(i))))**2, axis=0) <= s``
 |      Default ``s=len(w)`` which should be a good value if 1/w[i] is an
 |      estimate of the standard deviation of r[i].
 |  eps : float, optional
 |      A threshold for determining the effective rank of an over-determined
 |      linear system of equations. `eps` should have a value between 0 and 1,
 |      the default is 1e-16.
 |  
 |  Notes
 |  -----
 |  For more information, see the FITPACK_ site about this function.
 |  
 |  .. _FITPACK: http://www.netlib.org/dierckx/sphere.f
 |  
 |  Examples
 |  --------
 |  Suppose we have global data on a coarse grid (the input data does not
 |  have to be on a grid):
 |  
 |  >>> theta = np.linspace(0., np.pi, 7)
 |  >>> phi = np.linspace(0., 2*np.pi, 9)
 |  >>> data = np.empty((theta.shape[0], phi.shape[0]))
 |  >>> data[:,0], data[0,:], data[-1,:] = 0., 0., 0.
 |  >>> data[1:-1,1], data[1:-1,-1] = 1., 1.
 |  >>> data[1,1:-1], data[-2,1:-1] = 1., 1.
 |  >>> data[2:-2,2], data[2:-2,-2] = 2., 2.
 |  >>> data[2,2:-2], data[-3,2:-2] = 2., 2.
 |  >>> data[3,3:-2] = 3.
 |  >>> data = np.roll(data, 4, 1)
 |  
 |  We need to set up the interpolator object
 |  
 |  >>> lats, lons = np.meshgrid(theta, phi)
 |  >>> from scipy.interpolate import SmoothSphereBivariateSpline
 |  >>> lut = SmoothSphereBivariateSpline(lats.ravel(), lons.ravel(),
 |  ...                                   data.T.ravel(), s=3.5)
 |  
 |  As a first test, we'll see what the algorithm returns when run on the
 |  input coordinates
 |  
 |  >>> data_orig = lut(theta, phi)
 |  
 |  Finally we interpolate the data to a finer grid
 |  
 |  >>> fine_lats = np.linspace(0., np.pi, 70)
 |  >>> fine_lons = np.linspace(0., 2 * np.pi, 90)
 |  
 |  >>> data_smth = lut(fine_lats, fine_lons)
 |  
 |  >>> import matplotlib.pyplot as plt
 |  >>> fig = plt.figure()
 |  >>> ax1 = fig.add_subplot(131)
 |  >>> ax1.imshow(data, interpolation='nearest')
 |  >>> ax2 = fig.add_subplot(132)
 |  >>> ax2.imshow(data_orig, interpolation='nearest')
 |  >>> ax3 = fig.add_subplot(133)
 |  >>> ax3.imshow(data_smth, interpolation='nearest')
 |  >>> plt.show()
 |  
 |  Method resolution order:
 |      SmoothSphereBivariateSpline
 |      SphereBivariateSpline
 |      _BivariateSplineBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, theta, phi, r, w=None, s=0.0, eps=1e-16)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from SphereBivariateSpline:
 |  
 |  __call__(self, theta, phi, dtheta=0, dphi=0, grid=True)
 |      Evaluate the spline or its derivatives at given positions.
 |      
 |      Parameters
 |      ----------
 |      theta, phi : array_like
 |          Input coordinates.
 |      
 |          If `grid` is False, evaluate the spline at points
 |          ``(theta[i], phi[i]), i=0, ..., len(x)-1``.  Standard
 |          Numpy broadcasting is obeyed.
 |      
 |          If `grid` is True: evaluate spline at the grid points
 |          defined by the coordinate arrays theta, phi. The arrays
 |          must be sorted to increasing order.
 |      dtheta : int, optional
 |          Order of theta-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dphi : int
 |          Order of phi-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      grid : bool
 |          Whether to evaluate the results on a grid spanned by the
 |          input arrays, or at points specified by the input arrays.
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  ev(self, theta, phi, dtheta=0, dphi=0)
 |      Evaluate the spline at points
 |      
 |      Returns the interpolated value at ``(theta[i], phi[i]),
 |      i=0,...,len(theta)-1``.
 |      
 |      Parameters
 |      ----------
 |      theta, phi : array_like
 |          Input coordinates. Standard Numpy broadcasting is obeyed.
 |      dtheta : int, optional
 |          Order of theta-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dphi : int, optional
 |          Order of phi-derivative
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BivariateSplineBase:
 |  
 |  get_coeffs(self)
 |      Return spline coefficients.
 |  
 |  get_knots(self)
 |      Return a tuple (tx,ty) where tx,ty contain knots positions
 |      of the spline with respect to x-, y-variable, respectively.
 |      The position of interior and additional knots are given as
 |      t[k+1:-k-1] and t[:k+1]=b, t[-k-1:]=e, respectively.
 |  
 |  get_residual(self)
 |      Return weighted sum of squared residuals of the spline
 |      approximation: sum ((w[i]*(z[i]-s(x[i],y[i])))**2,axis=0)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BivariateSplineBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'theta', 'phi', 'r', 'w', 's', 'eps')","(nan, nan, nan, nan, None, 0.0, 1e-16)","(nan, nan, nan, nan, 'NoneType', 'float', 'float')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, theta, phi, r, w=None, s=0.0, eps=1e-16)',)"
scipy,1.1.0,scipy.interpolate.fitpack2.SphereBivariateSpline,interpolate.fitpack2,SphereBivariateSpline,"Python Library Documentation: class SphereBivariateSpline in module scipy.interpolate.fitpack2

class SphereBivariateSpline(_BivariateSplineBase)
 |  Bivariate spline s(x,y) of degrees 3 on a sphere, calculated from a
 |  given set of data points (theta,phi,r).
 |  
 |  .. versionadded:: 0.11.0
 |  
 |  See Also
 |  --------
 |  bisplrep, bisplev : an older wrapping of FITPACK
 |  UnivariateSpline : a similar class for univariate spline interpolation
 |  SmoothUnivariateSpline :
 |      to create a BivariateSpline through the given points
 |  LSQUnivariateSpline :
 |      to create a BivariateSpline using weighted least-squares fitting
 |  
 |  Method resolution order:
 |      SphereBivariateSpline
 |      _BivariateSplineBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __call__(self, theta, phi, dtheta=0, dphi=0, grid=True)
 |      Evaluate the spline or its derivatives at given positions.
 |      
 |      Parameters
 |      ----------
 |      theta, phi : array_like
 |          Input coordinates.
 |      
 |          If `grid` is False, evaluate the spline at points
 |          ``(theta[i], phi[i]), i=0, ..., len(x)-1``.  Standard
 |          Numpy broadcasting is obeyed.
 |      
 |          If `grid` is True: evaluate spline at the grid points
 |          defined by the coordinate arrays theta, phi. The arrays
 |          must be sorted to increasing order.
 |      dtheta : int, optional
 |          Order of theta-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dphi : int
 |          Order of phi-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      grid : bool
 |          Whether to evaluate the results on a grid spanned by the
 |          input arrays, or at points specified by the input arrays.
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  ev(self, theta, phi, dtheta=0, dphi=0)
 |      Evaluate the spline at points
 |      
 |      Returns the interpolated value at ``(theta[i], phi[i]),
 |      i=0,...,len(theta)-1``.
 |      
 |      Parameters
 |      ----------
 |      theta, phi : array_like
 |          Input coordinates. Standard Numpy broadcasting is obeyed.
 |      dtheta : int, optional
 |          Order of theta-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dphi : int, optional
 |          Order of phi-derivative
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BivariateSplineBase:
 |  
 |  get_coeffs(self)
 |      Return spline coefficients.
 |  
 |  get_knots(self)
 |      Return a tuple (tx,ty) where tx,ty contain knots positions
 |      of the spline with respect to x-, y-variable, respectively.
 |      The position of interior and additional knots are given as
 |      t[k+1:-k-1] and t[:k+1]=b, t[-k-1:]=e, respectively.
 |  
 |  get_residual(self)
 |      Return weighted sum of squared residuals of the spline
 |      approximation: sum ((w[i]*(z[i]-s(x[i],y[i])))**2,axis=0)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BivariateSplineBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.interpolate.fitpack2.SphereBivariateSpline,interpolate.fitpack2,SphereBivariateSpline,"Python Library Documentation: class SphereBivariateSpline in module scipy.interpolate.fitpack2

class SphereBivariateSpline(_BivariateSplineBase)
 |  Bivariate spline s(x,y) of degrees 3 on a sphere, calculated from a
 |  given set of data points (theta,phi,r).
 |  
 |  .. versionadded:: 0.11.0
 |  
 |  See Also
 |  --------
 |  bisplrep, bisplev : an older wrapping of FITPACK
 |  UnivariateSpline : a similar class for univariate spline interpolation
 |  SmoothUnivariateSpline :
 |      to create a BivariateSpline through the given points
 |  LSQUnivariateSpline :
 |      to create a BivariateSpline using weighted least-squares fitting
 |  
 |  Method resolution order:
 |      SphereBivariateSpline
 |      _BivariateSplineBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __call__(self, theta, phi, dtheta=0, dphi=0, grid=True)
 |      Evaluate the spline or its derivatives at given positions.
 |      
 |      Parameters
 |      ----------
 |      theta, phi : array_like
 |          Input coordinates.
 |      
 |          If `grid` is False, evaluate the spline at points
 |          ``(theta[i], phi[i]), i=0, ..., len(x)-1``.  Standard
 |          Numpy broadcasting is obeyed.
 |      
 |          If `grid` is True: evaluate spline at the grid points
 |          defined by the coordinate arrays theta, phi. The arrays
 |          must be sorted to increasing order.
 |      dtheta : int, optional
 |          Order of theta-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dphi : int
 |          Order of phi-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      grid : bool
 |          Whether to evaluate the results on a grid spanned by the
 |          input arrays, or at points specified by the input arrays.
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  ev(self, theta, phi, dtheta=0, dphi=0)
 |      Evaluate the spline at points
 |      
 |      Returns the interpolated value at ``(theta[i], phi[i]),
 |      i=0,...,len(theta)-1``.
 |      
 |      Parameters
 |      ----------
 |      theta, phi : array_like
 |          Input coordinates. Standard Numpy broadcasting is obeyed.
 |      dtheta : int, optional
 |          Order of theta-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dphi : int, optional
 |          Order of phi-derivative
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BivariateSplineBase:
 |  
 |  get_coeffs(self)
 |      Return spline coefficients.
 |  
 |  get_knots(self)
 |      Return a tuple (tx,ty) where tx,ty contain knots positions
 |      of the spline with respect to x-, y-variable, respectively.
 |      The position of interior and additional knots are given as
 |      t[k+1:-k-1] and t[:k+1]=b, t[-k-1:]=e, respectively.
 |  
 |  get_residual(self)
 |      Return weighted sum of squared residuals of the spline
 |      approximation: sum ((w[i]*(z[i]-s(x[i],y[i])))**2,axis=0)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BivariateSplineBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.interpolate.fitpack2.UnivariateSpline,interpolate.fitpack2,UnivariateSpline,"Python Library Documentation: class UnivariateSpline in module scipy.interpolate.fitpack2

class UnivariateSpline(builtins.object)
 |  One-dimensional smoothing spline fit to a given set of data points.
 |  
 |  Fits a spline y = spl(x) of degree `k` to the provided `x`, `y` data.  `s`
 |  specifies the number of knots by specifying a smoothing condition.
 |  
 |  Parameters
 |  ----------
 |  x : (N,) array_like
 |      1-D array of independent input data. Must be increasing.
 |  y : (N,) array_like
 |      1-D array of dependent input data, of the same length as `x`.
 |  w : (N,) array_like, optional
 |      Weights for spline fitting.  Must be positive.  If None (default),
 |      weights are all equal.
 |  bbox : (2,) array_like, optional
 |      2-sequence specifying the boundary of the approximation interval. If
 |      None (default), ``bbox=[x[0], x[-1]]``.
 |  k : int, optional
 |      Degree of the smoothing spline.  Must be <= 5.
 |      Default is k=3, a cubic spline.
 |  s : float or None, optional
 |      Positive smoothing factor used to choose the number of knots.  Number
 |      of knots will be increased until the smoothing condition is satisfied::
 |  
 |          sum((w[i] * (y[i]-spl(x[i])))**2, axis=0) <= s
 |  
 |      If None (default), ``s = len(w)`` which should be a good value if
 |      ``1/w[i]`` is an estimate of the standard deviation of ``y[i]``.
 |      If 0, spline will interpolate through all data points.
 |  ext : int or str, optional
 |      Controls the extrapolation mode for elements
 |      not in the interval defined by the knot sequence.
 |  
 |      * if ext=0 or 'extrapolate', return the extrapolated value.
 |      * if ext=1 or 'zeros', return 0
 |      * if ext=2 or 'raise', raise a ValueError
 |      * if ext=3 of 'const', return the boundary value.
 |  
 |      The default value is 0.
 |  
 |  check_finite : bool, optional
 |      Whether to check that the input arrays contain only finite numbers.
 |      Disabling may give a performance gain, but may result in problems
 |      (crashes, non-termination or non-sensical results) if the inputs
 |      do contain infinities or NaNs.
 |      Default is False.
 |  
 |  See Also
 |  --------
 |  InterpolatedUnivariateSpline : Subclass with smoothing forced to 0
 |  LSQUnivariateSpline : Subclass in which knots are user-selected instead of
 |      being set by smoothing condition
 |  splrep : An older, non object-oriented wrapping of FITPACK
 |  splev, sproot, splint, spalde
 |  BivariateSpline : A similar class for two-dimensional spline interpolation
 |  
 |  Notes
 |  -----
 |  The number of data points must be larger than the spline degree `k`.
 |  
 |  **NaN handling**: If the input arrays contain ``nan`` values, the result
 |  is not useful, since the underlying spline fitting routines cannot deal
 |  with ``nan`` . A workaround is to use zero weights for not-a-number
 |  data points:
 |  
 |  >>> from scipy.interpolate import UnivariateSpline
 |  >>> x, y = np.array([1, 2, 3, 4]), np.array([1, np.nan, 3, 4])
 |  >>> w = np.isnan(y)
 |  >>> y[w] = 0.
 |  >>> spl = UnivariateSpline(x, y, w=~w)
 |  
 |  Notice the need to replace a ``nan`` by a numerical value (precise value
 |  does not matter as long as the corresponding weight is zero.)
 |  
 |  Examples
 |  --------
 |  >>> import matplotlib.pyplot as plt
 |  >>> from scipy.interpolate import UnivariateSpline
 |  >>> x = np.linspace(-3, 3, 50)
 |  >>> y = np.exp(-x**2) + 0.1 * np.random.randn(50)
 |  >>> plt.plot(x, y, 'ro', ms=5)
 |  
 |  Use the default value for the smoothing parameter:
 |  
 |  >>> spl = UnivariateSpline(x, y)
 |  >>> xs = np.linspace(-3, 3, 1000)
 |  >>> plt.plot(xs, spl(xs), 'g', lw=3)
 |  
 |  Manually change the amount of smoothing:
 |  
 |  >>> spl.set_smoothing_factor(0.5)
 |  >>> plt.plot(xs, spl(xs), 'b', lw=3)
 |  >>> plt.show()
 |  
 |  Methods defined here:
 |  
 |  __call__(self, x, nu=0, ext=None)
 |      Evaluate spline (or its nu-th derivative) at positions x.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          A 1-D array of points at which to return the value of the smoothed
 |          spline or its derivatives. Note: x can be unordered but the
 |          evaluation is more efficient if x is (partially) ordered.
 |      nu  : int
 |          The order of derivative of the spline to compute.
 |      ext : int
 |          Controls the value returned for elements of ``x`` not in the
 |          interval defined by the knot sequence.
 |      
 |          * if ext=0 or 'extrapolate', return the extrapolated value.
 |          * if ext=1 or 'zeros', return 0
 |          * if ext=2 or 'raise', raise a ValueError
 |          * if ext=3 or 'const', return the boundary value.
 |      
 |          The default value is 0, passed from the initialization of
 |          UnivariateSpline.
 |  
 |  __init__(self, x, y, w=None, bbox=[None, None], k=3, s=None, ext=0, check_finite=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  antiderivative(self, n=1)
 |      Construct a new spline representing the antiderivative of this spline.
 |      
 |      Parameters
 |      ----------
 |      n : int, optional
 |          Order of antiderivative to evaluate. Default: 1
 |      
 |      Returns
 |      -------
 |      spline : UnivariateSpline
 |          Spline of order k2=k+n representing the antiderivative of this
 |          spline.
 |      
 |      Notes
 |      -----
 |      
 |      .. versionadded:: 0.13.0
 |      
 |      See Also
 |      --------
 |      splantider, derivative
 |      
 |      Examples
 |      --------
 |      >>> from scipy.interpolate import UnivariateSpline
 |      >>> x = np.linspace(0, np.pi/2, 70)
 |      >>> y = 1 / np.sqrt(1 - 0.8*np.sin(x)**2)
 |      >>> spl = UnivariateSpline(x, y, s=0)
 |      
 |      The derivative is the inverse operation of the antiderivative,
 |      although some floating point error accumulates:
 |      
 |      >>> spl(1.7), spl.antiderivative().derivative()(1.7)
 |      (array(2.1565429877197317), array(2.1565429877201865))
 |      
 |      Antiderivative can be used to evaluate definite integrals:
 |      
 |      >>> ispl = spl.antiderivative()
 |      >>> ispl(np.pi/2) - ispl(0)
 |      2.2572053588768486
 |      
 |      This is indeed an approximation to the complete elliptic integral
 |      :math:`K(m) = \int_0^{\pi/2} [1 - m\sin^2 x]^{-1/2} dx`:
 |      
 |      >>> from scipy.special import ellipk
 |      >>> ellipk(0.8)
 |      2.2572053268208538
 |  
 |  derivative(self, n=1)
 |      Construct a new spline representing the derivative of this spline.
 |      
 |      Parameters
 |      ----------
 |      n : int, optional
 |          Order of derivative to evaluate. Default: 1
 |      
 |      Returns
 |      -------
 |      spline : UnivariateSpline
 |          Spline of order k2=k-n representing the derivative of this
 |          spline.
 |      
 |      See Also
 |      --------
 |      splder, antiderivative
 |      
 |      Notes
 |      -----
 |      
 |      .. versionadded:: 0.13.0
 |      
 |      Examples
 |      --------
 |      This can be used for finding maxima of a curve:
 |      
 |      >>> from scipy.interpolate import UnivariateSpline
 |      >>> x = np.linspace(0, 10, 70)
 |      >>> y = np.sin(x)
 |      >>> spl = UnivariateSpline(x, y, k=4, s=0)
 |      
 |      Now, differentiate the spline and find the zeros of the
 |      derivative. (NB: `sproot` only works for order 3 splines, so we
 |      fit an order 4 spline):
 |      
 |      >>> spl.derivative().roots() / np.pi
 |      array([ 0.50000001,  1.5       ,  2.49999998])
 |      
 |      This agrees well with roots :math:`\pi/2 + n\pi` of
 |      :math:`\cos(x) = \sin'(x)`.
 |  
 |  derivatives(self, x)
 |      Return all derivatives of the spline at the point x.
 |      
 |      Parameters
 |      ----------
 |      x : float
 |          The point to evaluate the derivatives at.
 |      
 |      Returns
 |      -------
 |      der : ndarray, shape(k+1,)
 |          Derivatives of the orders 0 to k.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.interpolate import UnivariateSpline
 |      >>> x = np.linspace(0, 3, 11)
 |      >>> y = x**2
 |      >>> spl = UnivariateSpline(x, y)
 |      >>> spl.derivatives(1.5)
 |      array([2.25, 3.0, 2.0, 0])
 |  
 |  get_coeffs(self)
 |      Return spline coefficients.
 |  
 |  get_knots(self)
 |      Return positions of interior knots of the spline.
 |      
 |      Internally, the knot vector contains ``2*k`` additional boundary knots.
 |  
 |  get_residual(self)
 |      Return weighted sum of squared residuals of the spline approximation.
 |      
 |      This is equivalent to::
 |      
 |           sum((w[i] * (y[i]-spl(x[i])))**2, axis=0)
 |  
 |  integral(self, a, b)
 |      Return definite integral of the spline between two given points.
 |      
 |      Parameters
 |      ----------
 |      a : float
 |          Lower limit of integration.
 |      b : float
 |          Upper limit of integration.
 |      
 |      Returns
 |      -------
 |      integral : float
 |          The value of the definite integral of the spline between limits.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.interpolate import UnivariateSpline
 |      >>> x = np.linspace(0, 3, 11)
 |      >>> y = x**2
 |      >>> spl = UnivariateSpline(x, y)
 |      >>> spl.integral(0, 3)
 |      9.0
 |      
 |      which agrees with :math:`\int x^2 dx = x^3 / 3` between the limits
 |      of 0 and 3.
 |      
 |      A caveat is that this routine assumes the spline to be zero outside of
 |      the data limits:
 |      
 |      >>> spl.integral(-1, 4)
 |      9.0
 |      >>> spl.integral(-1, 0)
 |      0.0
 |  
 |  roots(self)
 |      Return the zeros of the spline.
 |      
 |      Restriction: only cubic splines are supported by fitpack.
 |  
 |  set_smoothing_factor(self, s)
 |      Continue spline computation with the given smoothing
 |      factor s and with the knots found at the last call.
 |      
 |      This routine modifies the spline in place.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, x, y, w=None, bbox=[None, None], k=3, s=None, ext=0, check_finite=False)',)",scipy,1.1.0,scipy.interpolate.fitpack2.UnivariateSpline,interpolate.fitpack2,UnivariateSpline,"Python Library Documentation: class UnivariateSpline in module scipy.interpolate.fitpack2

class UnivariateSpline(builtins.object)
 |  One-dimensional smoothing spline fit to a given set of data points.
 |  
 |  Fits a spline y = spl(x) of degree `k` to the provided `x`, `y` data.  `s`
 |  specifies the number of knots by specifying a smoothing condition.
 |  
 |  Parameters
 |  ----------
 |  x : (N,) array_like
 |      1-D array of independent input data. Must be increasing.
 |  y : (N,) array_like
 |      1-D array of dependent input data, of the same length as `x`.
 |  w : (N,) array_like, optional
 |      Weights for spline fitting.  Must be positive.  If None (default),
 |      weights are all equal.
 |  bbox : (2,) array_like, optional
 |      2-sequence specifying the boundary of the approximation interval. If
 |      None (default), ``bbox=[x[0], x[-1]]``.
 |  k : int, optional
 |      Degree of the smoothing spline.  Must be <= 5.
 |      Default is k=3, a cubic spline.
 |  s : float or None, optional
 |      Positive smoothing factor used to choose the number of knots.  Number
 |      of knots will be increased until the smoothing condition is satisfied::
 |  
 |          sum((w[i] * (y[i]-spl(x[i])))**2, axis=0) <= s
 |  
 |      If None (default), ``s = len(w)`` which should be a good value if
 |      ``1/w[i]`` is an estimate of the standard deviation of ``y[i]``.
 |      If 0, spline will interpolate through all data points.
 |  ext : int or str, optional
 |      Controls the extrapolation mode for elements
 |      not in the interval defined by the knot sequence.
 |  
 |      * if ext=0 or 'extrapolate', return the extrapolated value.
 |      * if ext=1 or 'zeros', return 0
 |      * if ext=2 or 'raise', raise a ValueError
 |      * if ext=3 of 'const', return the boundary value.
 |  
 |      The default value is 0.
 |  
 |  check_finite : bool, optional
 |      Whether to check that the input arrays contain only finite numbers.
 |      Disabling may give a performance gain, but may result in problems
 |      (crashes, non-termination or non-sensical results) if the inputs
 |      do contain infinities or NaNs.
 |      Default is False.
 |  
 |  See Also
 |  --------
 |  InterpolatedUnivariateSpline : Subclass with smoothing forced to 0
 |  LSQUnivariateSpline : Subclass in which knots are user-selected instead of
 |      being set by smoothing condition
 |  splrep : An older, non object-oriented wrapping of FITPACK
 |  splev, sproot, splint, spalde
 |  BivariateSpline : A similar class for two-dimensional spline interpolation
 |  
 |  Notes
 |  -----
 |  The number of data points must be larger than the spline degree `k`.
 |  
 |  **NaN handling**: If the input arrays contain ``nan`` values, the result
 |  is not useful, since the underlying spline fitting routines cannot deal
 |  with ``nan`` . A workaround is to use zero weights for not-a-number
 |  data points:
 |  
 |  >>> from scipy.interpolate import UnivariateSpline
 |  >>> x, y = np.array([1, 2, 3, 4]), np.array([1, np.nan, 3, 4])
 |  >>> w = np.isnan(y)
 |  >>> y[w] = 0.
 |  >>> spl = UnivariateSpline(x, y, w=~w)
 |  
 |  Notice the need to replace a ``nan`` by a numerical value (precise value
 |  does not matter as long as the corresponding weight is zero.)
 |  
 |  Examples
 |  --------
 |  >>> import matplotlib.pyplot as plt
 |  >>> from scipy.interpolate import UnivariateSpline
 |  >>> x = np.linspace(-3, 3, 50)
 |  >>> y = np.exp(-x**2) + 0.1 * np.random.randn(50)
 |  >>> plt.plot(x, y, 'ro', ms=5)
 |  
 |  Use the default value for the smoothing parameter:
 |  
 |  >>> spl = UnivariateSpline(x, y)
 |  >>> xs = np.linspace(-3, 3, 1000)
 |  >>> plt.plot(xs, spl(xs), 'g', lw=3)
 |  
 |  Manually change the amount of smoothing:
 |  
 |  >>> spl.set_smoothing_factor(0.5)
 |  >>> plt.plot(xs, spl(xs), 'b', lw=3)
 |  >>> plt.show()
 |  
 |  Methods defined here:
 |  
 |  __call__(self, x, nu=0, ext=None)
 |      Evaluate spline (or its nu-th derivative) at positions x.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          A 1-D array of points at which to return the value of the smoothed
 |          spline or its derivatives. Note: x can be unordered but the
 |          evaluation is more efficient if x is (partially) ordered.
 |      nu  : int
 |          The order of derivative of the spline to compute.
 |      ext : int
 |          Controls the value returned for elements of ``x`` not in the
 |          interval defined by the knot sequence.
 |      
 |          * if ext=0 or 'extrapolate', return the extrapolated value.
 |          * if ext=1 or 'zeros', return 0
 |          * if ext=2 or 'raise', raise a ValueError
 |          * if ext=3 or 'const', return the boundary value.
 |      
 |          The default value is 0, passed from the initialization of
 |          UnivariateSpline.
 |  
 |  __init__(self, x, y, w=None, bbox=[None, None], k=3, s=None, ext=0, check_finite=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  antiderivative(self, n=1)
 |      Construct a new spline representing the antiderivative of this spline.
 |      
 |      Parameters
 |      ----------
 |      n : int, optional
 |          Order of antiderivative to evaluate. Default: 1
 |      
 |      Returns
 |      -------
 |      spline : UnivariateSpline
 |          Spline of order k2=k+n representing the antiderivative of this
 |          spline.
 |      
 |      Notes
 |      -----
 |      
 |      .. versionadded:: 0.13.0
 |      
 |      See Also
 |      --------
 |      splantider, derivative
 |      
 |      Examples
 |      --------
 |      >>> from scipy.interpolate import UnivariateSpline
 |      >>> x = np.linspace(0, np.pi/2, 70)
 |      >>> y = 1 / np.sqrt(1 - 0.8*np.sin(x)**2)
 |      >>> spl = UnivariateSpline(x, y, s=0)
 |      
 |      The derivative is the inverse operation of the antiderivative,
 |      although some floating point error accumulates:
 |      
 |      >>> spl(1.7), spl.antiderivative().derivative()(1.7)
 |      (array(2.1565429877197317), array(2.1565429877201865))
 |      
 |      Antiderivative can be used to evaluate definite integrals:
 |      
 |      >>> ispl = spl.antiderivative()
 |      >>> ispl(np.pi/2) - ispl(0)
 |      2.2572053588768486
 |      
 |      This is indeed an approximation to the complete elliptic integral
 |      :math:`K(m) = \int_0^{\pi/2} [1 - m\sin^2 x]^{-1/2} dx`:
 |      
 |      >>> from scipy.special import ellipk
 |      >>> ellipk(0.8)
 |      2.2572053268208538
 |  
 |  derivative(self, n=1)
 |      Construct a new spline representing the derivative of this spline.
 |      
 |      Parameters
 |      ----------
 |      n : int, optional
 |          Order of derivative to evaluate. Default: 1
 |      
 |      Returns
 |      -------
 |      spline : UnivariateSpline
 |          Spline of order k2=k-n representing the derivative of this
 |          spline.
 |      
 |      See Also
 |      --------
 |      splder, antiderivative
 |      
 |      Notes
 |      -----
 |      
 |      .. versionadded:: 0.13.0
 |      
 |      Examples
 |      --------
 |      This can be used for finding maxima of a curve:
 |      
 |      >>> from scipy.interpolate import UnivariateSpline
 |      >>> x = np.linspace(0, 10, 70)
 |      >>> y = np.sin(x)
 |      >>> spl = UnivariateSpline(x, y, k=4, s=0)
 |      
 |      Now, differentiate the spline and find the zeros of the
 |      derivative. (NB: `sproot` only works for order 3 splines, so we
 |      fit an order 4 spline):
 |      
 |      >>> spl.derivative().roots() / np.pi
 |      array([ 0.50000001,  1.5       ,  2.49999998])
 |      
 |      This agrees well with roots :math:`\pi/2 + n\pi` of
 |      :math:`\cos(x) = \sin'(x)`.
 |  
 |  derivatives(self, x)
 |      Return all derivatives of the spline at the point x.
 |      
 |      Parameters
 |      ----------
 |      x : float
 |          The point to evaluate the derivatives at.
 |      
 |      Returns
 |      -------
 |      der : ndarray, shape(k+1,)
 |          Derivatives of the orders 0 to k.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.interpolate import UnivariateSpline
 |      >>> x = np.linspace(0, 3, 11)
 |      >>> y = x**2
 |      >>> spl = UnivariateSpline(x, y)
 |      >>> spl.derivatives(1.5)
 |      array([2.25, 3.0, 2.0, 0])
 |  
 |  get_coeffs(self)
 |      Return spline coefficients.
 |  
 |  get_knots(self)
 |      Return positions of interior knots of the spline.
 |      
 |      Internally, the knot vector contains ``2*k`` additional boundary knots.
 |  
 |  get_residual(self)
 |      Return weighted sum of squared residuals of the spline approximation.
 |      
 |      This is equivalent to::
 |      
 |           sum((w[i] * (y[i]-spl(x[i])))**2, axis=0)
 |  
 |  integral(self, a, b)
 |      Return definite integral of the spline between two given points.
 |      
 |      Parameters
 |      ----------
 |      a : float
 |          Lower limit of integration.
 |      b : float
 |          Upper limit of integration.
 |      
 |      Returns
 |      -------
 |      integral : float
 |          The value of the definite integral of the spline between limits.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.interpolate import UnivariateSpline
 |      >>> x = np.linspace(0, 3, 11)
 |      >>> y = x**2
 |      >>> spl = UnivariateSpline(x, y)
 |      >>> spl.integral(0, 3)
 |      9.0
 |      
 |      which agrees with :math:`\int x^2 dx = x^3 / 3` between the limits
 |      of 0 and 3.
 |      
 |      A caveat is that this routine assumes the spline to be zero outside of
 |      the data limits:
 |      
 |      >>> spl.integral(-1, 4)
 |      9.0
 |      >>> spl.integral(-1, 0)
 |      0.0
 |  
 |  roots(self)
 |      Return the zeros of the spline.
 |      
 |      Restriction: only cubic splines are supported by fitpack.
 |  
 |  set_smoothing_factor(self, s)
 |      Continue spline computation with the given smoothing
 |      factor s and with the knots found at the last call.
 |      
 |      This routine modifies the spline in place.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'x', 'y', 'w', 'bbox', 'k', 's', 'ext', 'check_finite')","(nan, nan, nan, None, [None, None], 3, None, 0, False)","(nan, nan, nan, 'NoneType', 'list', 'int', 'NoneType', 'int', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, x, y, w=None, bbox=[None, None], k=3, s=None, ext=0, check_finite=False)',)"
scipy,1.1.0,scipy.interpolate.fitpack2.UnivariateSpline._from_tck,interpolate.fitpack2.UnivariateSpline,_from_tck,"Python Library Documentation: method _from_tck in module scipy.interpolate.fitpack2

_from_tck(tck, ext=0) method of builtins.type instance
    Construct a spline object from given tck
",method,"('(tck, ext=0)',)",scipy,1.1.0,scipy.interpolate.fitpack2.UnivariateSpline._from_tck,interpolate.fitpack2.UnivariateSpline,_from_tck,"Python Library Documentation: method _from_tck in module scipy.interpolate.fitpack2

_from_tck(tck, ext=0) method of builtins.type instance
    Construct a spline object from given tck
",method,"('cls', 'tck', 'ext')","(nan, nan, 0)","(nan, nan, 'int')","('arg_info', 'arg_info', 'arg_info')","('(tck, ext=0)',)"
scipy,1.1.0,scipy.interpolate.fitpack2._BivariateSplineBase,interpolate.fitpack2,_BivariateSplineBase,"Python Library Documentation: class _BivariateSplineBase in module scipy.interpolate.fitpack2

class _BivariateSplineBase(builtins.object)
 |  Base class for Bivariate spline s(x,y) interpolation on the rectangle
 |  [xb,xe] x [yb, ye] calculated from a given set of data points
 |  (x,y,z).
 |  
 |  See Also
 |  --------
 |  bisplrep, bisplev : an older wrapping of FITPACK
 |  BivariateSpline :
 |      implementation of bivariate spline interpolation on a plane grid
 |  SphereBivariateSpline :
 |      implementation of bivariate spline interpolation on a spherical grid
 |  
 |  Methods defined here:
 |  
 |  __call__(self, x, y, dx=0, dy=0, grid=True)
 |      Evaluate the spline or its derivatives at given positions.
 |      
 |      Parameters
 |      ----------
 |      x, y : array_like
 |          Input coordinates.
 |      
 |          If `grid` is False, evaluate the spline at points ``(x[i],
 |          y[i]), i=0, ..., len(x)-1``.  Standard Numpy broadcasting
 |          is obeyed.
 |      
 |          If `grid` is True: evaluate spline at the grid points
 |          defined by the coordinate arrays x, y. The arrays must be
 |          sorted to increasing order.
 |          
 |          Note that the axis ordering is inverted relative to
 |          the output of meshgrid.
 |      dx : int
 |          Order of x-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dy : int
 |          Order of y-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      grid : bool
 |          Whether to evaluate the results on a grid spanned by the
 |          input arrays, or at points specified by the input arrays.
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  get_coeffs(self)
 |      Return spline coefficients.
 |  
 |  get_knots(self)
 |      Return a tuple (tx,ty) where tx,ty contain knots positions
 |      of the spline with respect to x-, y-variable, respectively.
 |      The position of interior and additional knots are given as
 |      t[k+1:-k-1] and t[:k+1]=b, t[-k-1:]=e, respectively.
 |  
 |  get_residual(self)
 |      Return weighted sum of squared residuals of the spline
 |      approximation: sum ((w[i]*(z[i]-s(x[i],y[i])))**2,axis=0)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.interpolate.fitpack2._BivariateSplineBase,interpolate.fitpack2,_BivariateSplineBase,"Python Library Documentation: class _BivariateSplineBase in module scipy.interpolate.fitpack2

class _BivariateSplineBase(builtins.object)
 |  Base class for Bivariate spline s(x,y) interpolation on the rectangle
 |  [xb,xe] x [yb, ye] calculated from a given set of data points
 |  (x,y,z).
 |  
 |  See Also
 |  --------
 |  bisplrep, bisplev : an older wrapping of FITPACK
 |  BivariateSpline :
 |      implementation of bivariate spline interpolation on a plane grid
 |  SphereBivariateSpline :
 |      implementation of bivariate spline interpolation on a spherical grid
 |  
 |  Methods defined here:
 |  
 |  __call__(self, x, y, dx=0, dy=0, grid=True)
 |      Evaluate the spline or its derivatives at given positions.
 |      
 |      Parameters
 |      ----------
 |      x, y : array_like
 |          Input coordinates.
 |      
 |          If `grid` is False, evaluate the spline at points ``(x[i],
 |          y[i]), i=0, ..., len(x)-1``.  Standard Numpy broadcasting
 |          is obeyed.
 |      
 |          If `grid` is True: evaluate spline at the grid points
 |          defined by the coordinate arrays x, y. The arrays must be
 |          sorted to increasing order.
 |          
 |          Note that the axis ordering is inverted relative to
 |          the output of meshgrid.
 |      dx : int
 |          Order of x-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dy : int
 |          Order of y-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      grid : bool
 |          Whether to evaluate the results on a grid spanned by the
 |          input arrays, or at points specified by the input arrays.
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  get_coeffs(self)
 |      Return spline coefficients.
 |  
 |  get_knots(self)
 |      Return a tuple (tx,ty) where tx,ty contain knots positions
 |      of the spline with respect to x-, y-variable, respectively.
 |      The position of interior and additional knots are given as
 |      t[k+1:-k-1] and t[:k+1]=b, t[-k-1:]=e, respectively.
 |  
 |  get_residual(self)
 |      Return weighted sum of squared residuals of the spline
 |      approximation: sum ((w[i]*(z[i]-s(x[i],y[i])))**2,axis=0)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.interpolate.fitpack2.all,interpolate.fitpack2,all,"Python Library Documentation: function all in module numpy.core.fromnumeric

all(a, axis=None, out=None, keepdims=<class 'numpy._globals._NoValue'>)
    Test whether all array elements along a given axis evaluate to True.
    
    Parameters
    ----------
    a : array_like
        Input array or object that can be converted to an array.
    axis : None or int or tuple of ints, optional
        Axis or axes along which a logical AND reduction is performed.
        The default (`axis` = `None`) is to perform a logical AND over all
        the dimensions of the input array. `axis` may be negative, in
        which case it counts from the last to the first axis.
    
        .. versionadded:: 1.7.0
    
        If this is a tuple of ints, a reduction is performed on multiple
        axes, instead of a single axis or all the axes as before.
    out : ndarray, optional
        Alternate output array in which to place the result.
        It must have the same shape as the expected output and its
        type is preserved (e.g., if ``dtype(out)`` is float, the result
        will consist of 0.0's and 1.0's).  See `doc.ufuncs` (Section
        ""Output arguments"") for more details.
    
    keepdims : bool, optional
        If this is set to True, the axes which are reduced are left
        in the result as dimensions with size one. With this option,
        the result will broadcast correctly against the input array.
    
        If the default value is passed, then `keepdims` will not be
        passed through to the `all` method of sub-classes of
        `ndarray`, however any non-default value will be.  If the
        sub-classes `sum` method does not implement `keepdims` any
        exceptions will be raised.
    
    Returns
    -------
    all : ndarray, bool
        A new boolean or array is returned unless `out` is specified,
        in which case a reference to `out` is returned.
    
    See Also
    --------
    ndarray.all : equivalent method
    
    any : Test whether any element along a given axis evaluates to True.
    
    Notes
    -----
    Not a Number (NaN), positive infinity and negative infinity
    evaluate to `True` because these are not equal to zero.
    
    Examples
    --------
    >>> np.all([[True,False],[True,True]])
    False
    
    >>> np.all([[True,False],[True,True]], axis=0)
    array([ True, False])
    
    >>> np.all([-1, 4, 5])
    True
    
    >>> np.all([1.0, np.nan])
    True
    
    >>> o=np.array([False])
    >>> z=np.all([-1, 4, 5], out=o)
    >>> id(z), id(o), z                             # doctest: +SKIP
    (28293632, 28293632, array([ True]))
",function,"(""(a, axis=None, out=None, keepdims=<class 'numpy._globals._NoValue'>)"",)",scipy,1.1.0,scipy.interpolate.fitpack2.all,interpolate.fitpack2,all,"Python Library Documentation: function all in module numpy.core.fromnumeric

all(a, axis=None, out=None, keepdims=<class 'numpy._globals._NoValue'>)
    Test whether all array elements along a given axis evaluate to True.
    
    Parameters
    ----------
    a : array_like
        Input array or object that can be converted to an array.
    axis : None or int or tuple of ints, optional
        Axis or axes along which a logical AND reduction is performed.
        The default (`axis` = `None`) is to perform a logical AND over all
        the dimensions of the input array. `axis` may be negative, in
        which case it counts from the last to the first axis.
    
        .. versionadded:: 1.7.0
    
        If this is a tuple of ints, a reduction is performed on multiple
        axes, instead of a single axis or all the axes as before.
    out : ndarray, optional
        Alternate output array in which to place the result.
        It must have the same shape as the expected output and its
        type is preserved (e.g., if ``dtype(out)`` is float, the result
        will consist of 0.0's and 1.0's).  See `doc.ufuncs` (Section
        ""Output arguments"") for more details.
    
    keepdims : bool, optional
        If this is set to True, the axes which are reduced are left
        in the result as dimensions with size one. With this option,
        the result will broadcast correctly against the input array.
    
        If the default value is passed, then `keepdims` will not be
        passed through to the `all` method of sub-classes of
        `ndarray`, however any non-default value will be.  If the
        sub-classes `sum` method does not implement `keepdims` any
        exceptions will be raised.
    
    Returns
    -------
    all : ndarray, bool
        A new boolean or array is returned unless `out` is specified,
        in which case a reference to `out` is returned.
    
    See Also
    --------
    ndarray.all : equivalent method
    
    any : Test whether any element along a given axis evaluates to True.
    
    Notes
    -----
    Not a Number (NaN), positive infinity and negative infinity
    evaluate to `True` because these are not equal to zero.
    
    Examples
    --------
    >>> np.all([[True,False],[True,True]])
    False
    
    >>> np.all([[True,False],[True,True]], axis=0)
    array([ True, False])
    
    >>> np.all([-1, 4, 5])
    True
    
    >>> np.all([1.0, np.nan])
    True
    
    >>> o=np.array([False])
    >>> z=np.all([-1, 4, 5], out=o)
    >>> id(z), id(o), z                             # doctest: +SKIP
    (28293632, 28293632, array([ True]))
",function,"('a', 'axis', 'out', 'keepdims')","(nan, None, None, <class 'numpy._globals._NoValue'>)","(nan, 'NoneType', 'NoneType', 'type')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a, axis=None, out=None, keepdims=<class 'numpy._globals._NoValue'>)"",)"
scipy,1.1.0,scipy.interpolate.fitpack2.alltrue,interpolate.fitpack2,alltrue,"Python Library Documentation: function alltrue in module numpy.core.fromnumeric

alltrue(a, axis=None, out=None, keepdims=<class 'numpy._globals._NoValue'>)
    Check if all elements of input array are true.
    
    See Also
    --------
    numpy.all : Equivalent function; see for details.
",function,"(""(a, axis=None, out=None, keepdims=<class 'numpy._globals._NoValue'>)"",)",scipy,1.1.0,scipy.interpolate.fitpack2.alltrue,interpolate.fitpack2,alltrue,"Python Library Documentation: function alltrue in module numpy.core.fromnumeric

alltrue(a, axis=None, out=None, keepdims=<class 'numpy._globals._NoValue'>)
    Check if all elements of input array are true.
    
    See Also
    --------
    numpy.all : Equivalent function; see for details.
",function,"('a', 'axis', 'out', 'keepdims')","(nan, None, None, <class 'numpy._globals._NoValue'>)","(nan, 'NoneType', 'NoneType', 'type')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a, axis=None, out=None, keepdims=<class 'numpy._globals._NoValue'>)"",)"
scipy,1.1.0,scipy.interpolate.fitpack2.diff,interpolate.fitpack2,diff,"Python Library Documentation: function diff in module numpy.lib.function_base

diff(a, n=1, axis=-1)
    Calculate the n-th discrete difference along the given axis.
    
    The first difference is given by ``out[n] = a[n+1] - a[n]`` along
    the given axis, higher differences are calculated by using `diff`
    recursively.
    
    Parameters
    ----------
    a : array_like
        Input array
    n : int, optional
        The number of times values are differenced. If zero, the input
        is returned as-is.
    axis : int, optional
        The axis along which the difference is taken, default is the
        last axis.
    
    Returns
    -------
    diff : ndarray
        The n-th differences. The shape of the output is the same as `a`
        except along `axis` where the dimension is smaller by `n`. The
        type of the output is the same as the type of the difference
        between any two elements of `a`. This is the same as the type of
        `a` in most cases. A notable exception is `datetime64`, which
        results in a `timedelta64` output array.
    
    See Also
    --------
    gradient, ediff1d, cumsum
    
    Notes
    -----
    Type is preserved for boolean arrays, so the result will contain
    `False` when consecutive elements are the same and `True` when they
    differ.
    
    For unsigned integer arrays, the results will also be unsigned. This
    should not be surprising, as the result is consistent with
    calculating the difference directly:
    
    >>> u8_arr = np.array([1, 0], dtype=np.uint8)
    >>> np.diff(u8_arr)
    array([255], dtype=uint8)
    >>> u8_arr[1,...] - u8_arr[0,...]
    array(255, np.uint8)
    
    If this is not desirable, then the array should be cast to a larger
    integer type first:
    
    >>> i16_arr = u8_arr.astype(np.int16)
    >>> np.diff(i16_arr)
    array([-1], dtype=int16)
    
    Examples
    --------
    >>> x = np.array([1, 2, 4, 7, 0])
    >>> np.diff(x)
    array([ 1,  2,  3, -7])
    >>> np.diff(x, n=2)
    array([  1,   1, -10])
    
    >>> x = np.array([[1, 3, 6, 10], [0, 5, 6, 8]])
    >>> np.diff(x)
    array([[2, 3, 4],
           [5, 1, 2]])
    >>> np.diff(x, axis=0)
    array([[-1,  2,  0, -2]])
    
    >>> x = np.arange('1066-10-13', '1066-10-16', dtype=np.datetime64)
    >>> np.diff(x)
    array([1, 1], dtype='timedelta64[D]')
",function,"('(a, n=1, axis=-1)',)",scipy,1.1.0,scipy.interpolate.fitpack2.diff,interpolate.fitpack2,diff,"Python Library Documentation: function diff in module numpy.lib.function_base

diff(a, n=1, axis=-1)
    Calculate the n-th discrete difference along the given axis.
    
    The first difference is given by ``out[n] = a[n+1] - a[n]`` along
    the given axis, higher differences are calculated by using `diff`
    recursively.
    
    Parameters
    ----------
    a : array_like
        Input array
    n : int, optional
        The number of times values are differenced. If zero, the input
        is returned as-is.
    axis : int, optional
        The axis along which the difference is taken, default is the
        last axis.
    
    Returns
    -------
    diff : ndarray
        The n-th differences. The shape of the output is the same as `a`
        except along `axis` where the dimension is smaller by `n`. The
        type of the output is the same as the type of the difference
        between any two elements of `a`. This is the same as the type of
        `a` in most cases. A notable exception is `datetime64`, which
        results in a `timedelta64` output array.
    
    See Also
    --------
    gradient, ediff1d, cumsum
    
    Notes
    -----
    Type is preserved for boolean arrays, so the result will contain
    `False` when consecutive elements are the same and `True` when they
    differ.
    
    For unsigned integer arrays, the results will also be unsigned. This
    should not be surprising, as the result is consistent with
    calculating the difference directly:
    
    >>> u8_arr = np.array([1, 0], dtype=np.uint8)
    >>> np.diff(u8_arr)
    array([255], dtype=uint8)
    >>> u8_arr[1,...] - u8_arr[0,...]
    array(255, np.uint8)
    
    If this is not desirable, then the array should be cast to a larger
    integer type first:
    
    >>> i16_arr = u8_arr.astype(np.int16)
    >>> np.diff(i16_arr)
    array([-1], dtype=int16)
    
    Examples
    --------
    >>> x = np.array([1, 2, 4, 7, 0])
    >>> np.diff(x)
    array([ 1,  2,  3, -7])
    >>> np.diff(x, n=2)
    array([  1,   1, -10])
    
    >>> x = np.array([[1, 3, 6, 10], [0, 5, 6, 8]])
    >>> np.diff(x)
    array([[2, 3, 4],
           [5, 1, 2]])
    >>> np.diff(x, axis=0)
    array([[-1,  2,  0, -2]])
    
    >>> x = np.arange('1066-10-13', '1066-10-16', dtype=np.datetime64)
    >>> np.diff(x)
    array([1, 1], dtype='timedelta64[D]')
",function,"('a', 'n', 'axis')","(nan, 1, -1)","(nan, 'int', 'int')","('arg_info', 'arg_info', 'arg_info')","('(a, n=1, axis=-1)',)"
scipy,1.1.0,scipy.interpolate.fitpack2.ones,interpolate.fitpack2,ones,"Python Library Documentation: function ones in module numpy.core.numeric

ones(shape, dtype=None, order='C')
    Return a new array of given shape and type, filled with ones.
    
    Parameters
    ----------
    shape : int or sequence of ints
        Shape of the new array, e.g., ``(2, 3)`` or ``2``.
    dtype : data-type, optional
        The desired data-type for the array, e.g., `numpy.int8`.  Default is
        `numpy.float64`.
    order : {'C', 'F'}, optional
        Whether to store multidimensional data in C- or Fortran-contiguous
        (row- or column-wise) order in memory.
    
    Returns
    -------
    out : ndarray
        Array of ones with the given shape, dtype, and order.
    
    See Also
    --------
    zeros, ones_like
    
    Examples
    --------
    >>> np.ones(5)
    array([ 1.,  1.,  1.,  1.,  1.])
    
    >>> np.ones((5,), dtype=int)
    array([1, 1, 1, 1, 1])
    
    >>> np.ones((2, 1))
    array([[ 1.],
           [ 1.]])
    
    >>> s = (2,2)
    >>> np.ones(s)
    array([[ 1.,  1.],
           [ 1.,  1.]])
",function,"(""(shape, dtype=None, order='C')"",)",scipy,1.1.0,scipy.interpolate.fitpack2.ones,interpolate.fitpack2,ones,"Python Library Documentation: function ones in module numpy.core.numeric

ones(shape, dtype=None, order='C')
    Return a new array of given shape and type, filled with ones.
    
    Parameters
    ----------
    shape : int or sequence of ints
        Shape of the new array, e.g., ``(2, 3)`` or ``2``.
    dtype : data-type, optional
        The desired data-type for the array, e.g., `numpy.int8`.  Default is
        `numpy.float64`.
    order : {'C', 'F'}, optional
        Whether to store multidimensional data in C- or Fortran-contiguous
        (row- or column-wise) order in memory.
    
    Returns
    -------
    out : ndarray
        Array of ones with the given shape, dtype, and order.
    
    See Also
    --------
    zeros, ones_like
    
    Examples
    --------
    >>> np.ones(5)
    array([ 1.,  1.,  1.,  1.,  1.])
    
    >>> np.ones((5,), dtype=int)
    array([1, 1, 1, 1, 1])
    
    >>> np.ones((2, 1))
    array([[ 1.],
           [ 1.]])
    
    >>> s = (2,2)
    >>> np.ones(s)
    array([[ 1.,  1.],
           [ 1.,  1.]])
",function,"('shape', 'dtype', 'order')","(nan, None, 'C')","(nan, 'NoneType', 'str')","('arg_info', 'arg_info', 'arg_info')","(""(shape, dtype=None, order='C')"",)"
scipy,1.1.0,scipy.interpolate.fitpack2.ravel,interpolate.fitpack2,ravel,"Python Library Documentation: function ravel in module numpy.core.fromnumeric

ravel(a, order='C')
    Return a contiguous flattened array.
    
    A 1-D array, containing the elements of the input, is returned.  A copy is
    made only if needed.
    
    As of NumPy 1.10, the returned array will have the same type as the input
    array. (for example, a masked array will be returned for a masked array
    input)
    
    Parameters
    ----------
    a : array_like
        Input array.  The elements in `a` are read in the order specified by
        `order`, and packed as a 1-D array.
    order : {'C','F', 'A', 'K'}, optional
    
        The elements of `a` are read using this index order. 'C' means
        to index the elements in row-major, C-style order,
        with the last axis index changing fastest, back to the first
        axis index changing slowest.  'F' means to index the elements
        in column-major, Fortran-style order, with the
        first index changing fastest, and the last index changing
        slowest. Note that the 'C' and 'F' options take no account of
        the memory layout of the underlying array, and only refer to
        the order of axis indexing.  'A' means to read the elements in
        Fortran-like index order if `a` is Fortran *contiguous* in
        memory, C-like order otherwise.  'K' means to read the
        elements in the order they occur in memory, except for
        reversing the data when strides are negative.  By default, 'C'
        index order is used.
    
    Returns
    -------
    y : array_like
        If `a` is a matrix, y is a 1-D ndarray, otherwise y is an array of
        the same subtype as `a`. The shape of the returned array is
        ``(a.size,)``. Matrices are special cased for backward
        compatibility.
    
    See Also
    --------
    ndarray.flat : 1-D iterator over an array.
    ndarray.flatten : 1-D array copy of the elements of an array
                      in row-major order.
    ndarray.reshape : Change the shape of an array without changing its data.
    
    Notes
    -----
    In row-major, C-style order, in two dimensions, the row index
    varies the slowest, and the column index the quickest.  This can
    be generalized to multiple dimensions, where row-major order
    implies that the index along the first axis varies slowest, and
    the index along the last quickest.  The opposite holds for
    column-major, Fortran-style index ordering.
    
    When a view is desired in as many cases as possible, ``arr.reshape(-1)``
    may be preferable.
    
    Examples
    --------
    It is equivalent to ``reshape(-1, order=order)``.
    
    >>> x = np.array([[1, 2, 3], [4, 5, 6]])
    >>> print(np.ravel(x))
    [1 2 3 4 5 6]
    
    >>> print(x.reshape(-1))
    [1 2 3 4 5 6]
    
    >>> print(np.ravel(x, order='F'))
    [1 4 2 5 3 6]
    
    When ``order`` is 'A', it will preserve the array's 'C' or 'F' ordering:
    
    >>> print(np.ravel(x.T))
    [1 4 2 5 3 6]
    >>> print(np.ravel(x.T, order='A'))
    [1 2 3 4 5 6]
    
    When ``order`` is 'K', it will preserve orderings that are neither 'C'
    nor 'F', but won't reverse axes:
    
    >>> a = np.arange(3)[::-1]; a
    array([2, 1, 0])
    >>> a.ravel(order='C')
    array([2, 1, 0])
    >>> a.ravel(order='K')
    array([2, 1, 0])
    
    >>> a = np.arange(12).reshape(2,3,2).swapaxes(1,2); a
    array([[[ 0,  2,  4],
            [ 1,  3,  5]],
           [[ 6,  8, 10],
            [ 7,  9, 11]]])
    >>> a.ravel(order='C')
    array([ 0,  2,  4,  1,  3,  5,  6,  8, 10,  7,  9, 11])
    >>> a.ravel(order='K')
    array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
",function,"(""(a, order='C')"",)",scipy,1.1.0,scipy.interpolate.fitpack2.ravel,interpolate.fitpack2,ravel,"Python Library Documentation: function ravel in module numpy.core.fromnumeric

ravel(a, order='C')
    Return a contiguous flattened array.
    
    A 1-D array, containing the elements of the input, is returned.  A copy is
    made only if needed.
    
    As of NumPy 1.10, the returned array will have the same type as the input
    array. (for example, a masked array will be returned for a masked array
    input)
    
    Parameters
    ----------
    a : array_like
        Input array.  The elements in `a` are read in the order specified by
        `order`, and packed as a 1-D array.
    order : {'C','F', 'A', 'K'}, optional
    
        The elements of `a` are read using this index order. 'C' means
        to index the elements in row-major, C-style order,
        with the last axis index changing fastest, back to the first
        axis index changing slowest.  'F' means to index the elements
        in column-major, Fortran-style order, with the
        first index changing fastest, and the last index changing
        slowest. Note that the 'C' and 'F' options take no account of
        the memory layout of the underlying array, and only refer to
        the order of axis indexing.  'A' means to read the elements in
        Fortran-like index order if `a` is Fortran *contiguous* in
        memory, C-like order otherwise.  'K' means to read the
        elements in the order they occur in memory, except for
        reversing the data when strides are negative.  By default, 'C'
        index order is used.
    
    Returns
    -------
    y : array_like
        If `a` is a matrix, y is a 1-D ndarray, otherwise y is an array of
        the same subtype as `a`. The shape of the returned array is
        ``(a.size,)``. Matrices are special cased for backward
        compatibility.
    
    See Also
    --------
    ndarray.flat : 1-D iterator over an array.
    ndarray.flatten : 1-D array copy of the elements of an array
                      in row-major order.
    ndarray.reshape : Change the shape of an array without changing its data.
    
    Notes
    -----
    In row-major, C-style order, in two dimensions, the row index
    varies the slowest, and the column index the quickest.  This can
    be generalized to multiple dimensions, where row-major order
    implies that the index along the first axis varies slowest, and
    the index along the last quickest.  The opposite holds for
    column-major, Fortran-style index ordering.
    
    When a view is desired in as many cases as possible, ``arr.reshape(-1)``
    may be preferable.
    
    Examples
    --------
    It is equivalent to ``reshape(-1, order=order)``.
    
    >>> x = np.array([[1, 2, 3], [4, 5, 6]])
    >>> print(np.ravel(x))
    [1 2 3 4 5 6]
    
    >>> print(x.reshape(-1))
    [1 2 3 4 5 6]
    
    >>> print(np.ravel(x, order='F'))
    [1 4 2 5 3 6]
    
    When ``order`` is 'A', it will preserve the array's 'C' or 'F' ordering:
    
    >>> print(np.ravel(x.T))
    [1 4 2 5 3 6]
    >>> print(np.ravel(x.T, order='A'))
    [1 2 3 4 5 6]
    
    When ``order`` is 'K', it will preserve orderings that are neither 'C'
    nor 'F', but won't reverse axes:
    
    >>> a = np.arange(3)[::-1]; a
    array([2, 1, 0])
    >>> a.ravel(order='C')
    array([2, 1, 0])
    >>> a.ravel(order='K')
    array([2, 1, 0])
    
    >>> a = np.arange(12).reshape(2,3,2).swapaxes(1,2); a
    array([[[ 0,  2,  4],
            [ 1,  3,  5]],
           [[ 6,  8, 10],
            [ 7,  9, 11]]])
    >>> a.ravel(order='C')
    array([ 0,  2,  4,  1,  3,  5,  6,  8, 10,  7,  9, 11])
    >>> a.ravel(order='K')
    array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
",function,"('a', 'order')","(nan, 'C')","(nan, 'str')","('arg_info', 'arg_info')","(""(a, order='C')"",)"
scipy,1.1.0,scipy.interpolate.interpnd.CloughTocher2DInterpolator,interpolate.interpnd,CloughTocher2DInterpolator,"Python Library Documentation: class CloughTocher2DInterpolator in module scipy.interpolate.interpnd

class CloughTocher2DInterpolator(NDInterpolatorBase)
 |  CloughTocher2DInterpolator(points, values, tol=1e-6)
 |  
 |  Piecewise cubic, C1 smooth, curvature-minimizing interpolant in 2D.
 |  
 |  .. versionadded:: 0.9
 |  
 |  Methods
 |  -------
 |  __call__
 |  
 |  Parameters
 |  ----------
 |  points : ndarray of floats, shape (npoints, ndims); or Delaunay
 |      Data point coordinates, or a precomputed Delaunay triangulation.
 |  values : ndarray of float or complex, shape (npoints, ...)
 |      Data values.
 |  fill_value : float, optional
 |      Value used to fill in for requested points outside of the
 |      convex hull of the input points.  If not provided, then
 |      the default is ``nan``.
 |  tol : float, optional
 |      Absolute/relative tolerance for gradient estimation.
 |  maxiter : int, optional
 |      Maximum number of iterations in gradient estimation.
 |  rescale : bool, optional
 |      Rescale points to unit cube before performing interpolation.
 |      This is useful if some of the input dimensions have
 |      incommensurable units and differ by many orders of magnitude.
 |  
 |  Notes
 |  -----
 |  The interpolant is constructed by triangulating the input data
 |  with Qhull [1]_, and constructing a piecewise cubic
 |  interpolating Bezier polynomial on each triangle, using a
 |  Clough-Tocher scheme [CT]_.  The interpolant is guaranteed to be
 |  continuously differentiable.
 |  
 |  The gradients of the interpolant are chosen so that the curvature
 |  of the interpolating surface is approximatively minimized. The
 |  gradients necessary for this are estimated using the global
 |  algorithm described in [Nielson83,Renka84]_.
 |  
 |  References
 |  ----------
 |  .. [1] http://www.qhull.org/
 |  
 |  .. [CT] See, for example,
 |     P. Alfeld,
 |     ''A trivariate Clough-Tocher scheme for tetrahedral data''.
 |     Computer Aided Geometric Design, 1, 169 (1984);
 |     G. Farin,
 |     ''Triangular Bernstein-Bezier patches''.
 |     Computer Aided Geometric Design, 3, 83 (1986).
 |  
 |  .. [Nielson83] G. Nielson,
 |     ''A method for interpolating scattered data based upon a minimum norm
 |     network''.
 |     Math. Comp., 40, 253 (1983).
 |  
 |  .. [Renka84] R. J. Renka and A. K. Cline.
 |     ''A Triangle-based C1 interpolation method.'',
 |     Rocky Mountain J. Math., 14, 223 (1984).
 |  
 |  Method resolution order:
 |      CloughTocher2DInterpolator
 |      NDInterpolatorBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, points, values, fill_value=nan, tol=1e-06, maxiter=400, rescale=False)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from NDInterpolatorBase:
 |  
 |  __call__(self, *args)
 |      interpolator(xi)
 |      
 |      Evaluate interpolator at given points.
 |      
 |      Parameters
 |      ----------
 |      xi : ndarray of float, shape (..., ndim)
 |          Points where to interpolate data at.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from NDInterpolatorBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, points, values, fill_value=nan, tol=1e-06, maxiter=400, rescale=False)',)",scipy,1.1.0,scipy.interpolate.interpnd.CloughTocher2DInterpolator,interpolate.interpnd,CloughTocher2DInterpolator,"Python Library Documentation: class CloughTocher2DInterpolator in module scipy.interpolate.interpnd

class CloughTocher2DInterpolator(NDInterpolatorBase)
 |  CloughTocher2DInterpolator(points, values, tol=1e-6)
 |  
 |  Piecewise cubic, C1 smooth, curvature-minimizing interpolant in 2D.
 |  
 |  .. versionadded:: 0.9
 |  
 |  Methods
 |  -------
 |  __call__
 |  
 |  Parameters
 |  ----------
 |  points : ndarray of floats, shape (npoints, ndims); or Delaunay
 |      Data point coordinates, or a precomputed Delaunay triangulation.
 |  values : ndarray of float or complex, shape (npoints, ...)
 |      Data values.
 |  fill_value : float, optional
 |      Value used to fill in for requested points outside of the
 |      convex hull of the input points.  If not provided, then
 |      the default is ``nan``.
 |  tol : float, optional
 |      Absolute/relative tolerance for gradient estimation.
 |  maxiter : int, optional
 |      Maximum number of iterations in gradient estimation.
 |  rescale : bool, optional
 |      Rescale points to unit cube before performing interpolation.
 |      This is useful if some of the input dimensions have
 |      incommensurable units and differ by many orders of magnitude.
 |  
 |  Notes
 |  -----
 |  The interpolant is constructed by triangulating the input data
 |  with Qhull [1]_, and constructing a piecewise cubic
 |  interpolating Bezier polynomial on each triangle, using a
 |  Clough-Tocher scheme [CT]_.  The interpolant is guaranteed to be
 |  continuously differentiable.
 |  
 |  The gradients of the interpolant are chosen so that the curvature
 |  of the interpolating surface is approximatively minimized. The
 |  gradients necessary for this are estimated using the global
 |  algorithm described in [Nielson83,Renka84]_.
 |  
 |  References
 |  ----------
 |  .. [1] http://www.qhull.org/
 |  
 |  .. [CT] See, for example,
 |     P. Alfeld,
 |     ''A trivariate Clough-Tocher scheme for tetrahedral data''.
 |     Computer Aided Geometric Design, 1, 169 (1984);
 |     G. Farin,
 |     ''Triangular Bernstein-Bezier patches''.
 |     Computer Aided Geometric Design, 3, 83 (1986).
 |  
 |  .. [Nielson83] G. Nielson,
 |     ''A method for interpolating scattered data based upon a minimum norm
 |     network''.
 |     Math. Comp., 40, 253 (1983).
 |  
 |  .. [Renka84] R. J. Renka and A. K. Cline.
 |     ''A Triangle-based C1 interpolation method.'',
 |     Rocky Mountain J. Math., 14, 223 (1984).
 |  
 |  Method resolution order:
 |      CloughTocher2DInterpolator
 |      NDInterpolatorBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, points, values, fill_value=nan, tol=1e-06, maxiter=400, rescale=False)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from NDInterpolatorBase:
 |  
 |  __call__(self, *args)
 |      interpolator(xi)
 |      
 |      Evaluate interpolator at given points.
 |      
 |      Parameters
 |      ----------
 |      xi : ndarray of float, shape (..., ndim)
 |          Points where to interpolate data at.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from NDInterpolatorBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'points', 'values', 'fill_value', 'tol', 'maxiter', 'rescale')","(nan, nan, nan, nan, 1e-06, 400, False)","(nan, nan, nan, nan, 'float', 'int', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, points, values, fill_value=nan, tol=1e-06, maxiter=400, rescale=False)',)"
scipy,1.1.0,scipy.interpolate.interpnd.GradientEstimationWarning,interpolate.interpnd,GradientEstimationWarning,"Python Library Documentation: class GradientEstimationWarning in module scipy.interpolate.interpnd

class GradientEstimationWarning(builtins.Warning)
 |  Base class for warning categories.
 |  
 |  Method resolution order:
 |      GradientEstimationWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Warning:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.interpolate.interpnd.GradientEstimationWarning,interpolate.interpnd,GradientEstimationWarning,"Python Library Documentation: class GradientEstimationWarning in module scipy.interpolate.interpnd

class GradientEstimationWarning(builtins.Warning)
 |  Base class for warning categories.
 |  
 |  Method resolution order:
 |      GradientEstimationWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Warning:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.interpolate.interpnd.LinearNDInterpolator,interpolate.interpnd,LinearNDInterpolator,"Python Library Documentation: class LinearNDInterpolator in module scipy.interpolate.interpnd

class LinearNDInterpolator(NDInterpolatorBase)
 |  LinearNDInterpolator(points, values, fill_value=np.nan, rescale=False)
 |  
 |  Piecewise linear interpolant in N dimensions.
 |  
 |  .. versionadded:: 0.9
 |  
 |  Methods
 |  -------
 |  __call__
 |  
 |  Parameters
 |  ----------
 |  points : ndarray of floats, shape (npoints, ndims); or Delaunay
 |      Data point coordinates, or a precomputed Delaunay triangulation.
 |  values : ndarray of float or complex, shape (npoints, ...)
 |      Data values.
 |  fill_value : float, optional
 |      Value used to fill in for requested points outside of the
 |      convex hull of the input points.  If not provided, then
 |      the default is ``nan``.
 |  rescale : bool, optional
 |      Rescale points to unit cube before performing interpolation.
 |      This is useful if some of the input dimensions have
 |      incommensurable units and differ by many orders of magnitude.
 |  
 |  Notes
 |  -----
 |  The interpolant is constructed by triangulating the input data
 |  with Qhull [1]_, and on each triangle performing linear
 |  barycentric interpolation.
 |  
 |  References
 |  ----------
 |  .. [1] http://www.qhull.org/
 |  
 |  Method resolution order:
 |      LinearNDInterpolator
 |      NDInterpolatorBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, points, values, fill_value=nan, rescale=False)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from NDInterpolatorBase:
 |  
 |  __call__(self, *args)
 |      interpolator(xi)
 |      
 |      Evaluate interpolator at given points.
 |      
 |      Parameters
 |      ----------
 |      xi : ndarray of float, shape (..., ndim)
 |          Points where to interpolate data at.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from NDInterpolatorBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, points, values, fill_value=nan, rescale=False)',)",scipy,1.1.0,scipy.interpolate.interpnd.LinearNDInterpolator,interpolate.interpnd,LinearNDInterpolator,"Python Library Documentation: class LinearNDInterpolator in module scipy.interpolate.interpnd

class LinearNDInterpolator(NDInterpolatorBase)
 |  LinearNDInterpolator(points, values, fill_value=np.nan, rescale=False)
 |  
 |  Piecewise linear interpolant in N dimensions.
 |  
 |  .. versionadded:: 0.9
 |  
 |  Methods
 |  -------
 |  __call__
 |  
 |  Parameters
 |  ----------
 |  points : ndarray of floats, shape (npoints, ndims); or Delaunay
 |      Data point coordinates, or a precomputed Delaunay triangulation.
 |  values : ndarray of float or complex, shape (npoints, ...)
 |      Data values.
 |  fill_value : float, optional
 |      Value used to fill in for requested points outside of the
 |      convex hull of the input points.  If not provided, then
 |      the default is ``nan``.
 |  rescale : bool, optional
 |      Rescale points to unit cube before performing interpolation.
 |      This is useful if some of the input dimensions have
 |      incommensurable units and differ by many orders of magnitude.
 |  
 |  Notes
 |  -----
 |  The interpolant is constructed by triangulating the input data
 |  with Qhull [1]_, and on each triangle performing linear
 |  barycentric interpolation.
 |  
 |  References
 |  ----------
 |  .. [1] http://www.qhull.org/
 |  
 |  Method resolution order:
 |      LinearNDInterpolator
 |      NDInterpolatorBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, points, values, fill_value=nan, rescale=False)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from NDInterpolatorBase:
 |  
 |  __call__(self, *args)
 |      interpolator(xi)
 |      
 |      Evaluate interpolator at given points.
 |      
 |      Parameters
 |      ----------
 |      xi : ndarray of float, shape (..., ndim)
 |          Points where to interpolate data at.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from NDInterpolatorBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'points', 'values', 'fill_value', 'rescale')","(nan, nan, nan, nan, False)","(nan, nan, nan, nan, 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, points, values, fill_value=nan, rescale=False)',)"
scipy,1.1.0,scipy.interpolate.interpnd.NDInterpolatorBase,interpolate.interpnd,NDInterpolatorBase,"Python Library Documentation: class NDInterpolatorBase in module scipy.interpolate.interpnd

class NDInterpolatorBase(builtins.object)
 |  Common routines for interpolators.
 |  
 |  .. versionadded:: 0.9
 |  
 |  Methods defined here:
 |  
 |  __call__(self, *args)
 |      interpolator(xi)
 |      
 |      Evaluate interpolator at given points.
 |      
 |      Parameters
 |      ----------
 |      xi : ndarray of float, shape (..., ndim)
 |          Points where to interpolate data at.
 |  
 |  __init__(self, points, values, fill_value=nan, ndim=None, rescale=False, need_contiguous=True, need_values=True)
 |      Check shape of points and values arrays, and reshape values to
 |      (npoints, nvalues).  Ensure the `points` and values arrays are
 |      C-contiguous, and of correct type.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, points, values, fill_value=nan, ndim=None, rescale=False, need_contiguous=True, need_values=True)',)",scipy,1.1.0,scipy.interpolate.interpnd.NDInterpolatorBase,interpolate.interpnd,NDInterpolatorBase,"Python Library Documentation: class NDInterpolatorBase in module scipy.interpolate.interpnd

class NDInterpolatorBase(builtins.object)
 |  Common routines for interpolators.
 |  
 |  .. versionadded:: 0.9
 |  
 |  Methods defined here:
 |  
 |  __call__(self, *args)
 |      interpolator(xi)
 |      
 |      Evaluate interpolator at given points.
 |      
 |      Parameters
 |      ----------
 |      xi : ndarray of float, shape (..., ndim)
 |          Points where to interpolate data at.
 |  
 |  __init__(self, points, values, fill_value=nan, ndim=None, rescale=False, need_contiguous=True, need_values=True)
 |      Check shape of points and values arrays, and reshape values to
 |      (npoints, nvalues).  Ensure the `points` and values arrays are
 |      C-contiguous, and of correct type.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'points', 'values', 'fill_value', 'ndim', 'rescale', 'need_contiguous', 'need_values')","(nan, nan, nan, nan, None, False, True, True)","(nan, nan, nan, nan, 'NoneType', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, points, values, fill_value=nan, ndim=None, rescale=False, need_contiguous=True, need_values=True)',)"
scipy,1.1.0,scipy.interpolate.interpolate.BPoly,interpolate.interpolate,BPoly,"Python Library Documentation: class BPoly in module scipy.interpolate.interpolate

class BPoly(_PPolyBase)
 |  Piecewise polynomial in terms of coefficients and breakpoints.
 |  
 |  The polynomial between ``x[i]`` and ``x[i + 1]`` is written in the
 |  Bernstein polynomial basis::
 |  
 |      S = sum(c[a, i] * b(a, k; x) for a in range(k+1)),
 |  
 |  where ``k`` is the degree of the polynomial, and::
 |  
 |      b(a, k; x) = binom(k, a) * t**a * (1 - t)**(k - a),
 |  
 |  with ``t = (x - x[i]) / (x[i+1] - x[i])`` and ``binom`` is the binomial
 |  coefficient.
 |  
 |  Parameters
 |  ----------
 |  c : ndarray, shape (k, m, ...)
 |      Polynomial coefficients, order `k` and `m` intervals
 |  x : ndarray, shape (m+1,)
 |      Polynomial breakpoints. Must be sorted in either increasing or
 |      decreasing order.
 |  extrapolate : bool, optional
 |      If bool, determines whether to extrapolate to out-of-bounds points
 |      based on first and last intervals, or to return NaNs. If 'periodic',
 |      periodic extrapolation is used. Default is True.
 |  axis : int, optional
 |      Interpolation axis. Default is zero.
 |  
 |  Attributes
 |  ----------
 |  x : ndarray
 |      Breakpoints.
 |  c : ndarray
 |      Coefficients of the polynomials. They are reshaped
 |      to a 3-dimensional array with the last dimension representing
 |      the trailing dimensions of the original coefficient array.
 |  axis : int
 |      Interpolation axis.
 |  
 |  Methods
 |  -------
 |  __call__
 |  extend
 |  derivative
 |  antiderivative
 |  integrate
 |  construct_fast
 |  from_power_basis
 |  from_derivatives
 |  
 |  See also
 |  --------
 |  PPoly : piecewise polynomials in the power basis
 |  
 |  Notes
 |  -----
 |  Properties of Bernstein polynomials are well documented in the literature.
 |  Here's a non-exhaustive list:
 |  
 |  .. [1] http://en.wikipedia.org/wiki/Bernstein_polynomial
 |  
 |  .. [2] Kenneth I. Joy, Bernstein polynomials,
 |    http://www.idav.ucdavis.edu/education/CAGDNotes/Bernstein-Polynomials.pdf
 |  
 |  .. [3] E. H. Doha, A. H. Bhrawy, and M. A. Saker, Boundary Value Problems,
 |       vol 2011, article ID 829546, :doi:`10.1155/2011/829543`.
 |  
 |  Examples
 |  --------
 |  >>> from scipy.interpolate import BPoly
 |  >>> x = [0, 1]
 |  >>> c = [[1], [2], [3]]
 |  >>> bp = BPoly(c, x)
 |  
 |  This creates a 2nd order polynomial
 |  
 |  .. math::
 |  
 |      B(x) = 1 \times b_{0, 2}(x) + 2 \times b_{1, 2}(x) + 3 \times b_{2, 2}(x) \\
 |           = 1 \times (1-x)^2 + 2 \times 2 x (1 - x) + 3 \times x^2
 |  
 |  Method resolution order:
 |      BPoly
 |      _PPolyBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  antiderivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the antiderivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of antiderivative to evaluate. Default is 1, i.e. compute
 |          the first integral. If negative, the derivative is returned.
 |      
 |      Returns
 |      -------
 |      bp : BPoly
 |          Piecewise polynomial of order k + nu representing the
 |          antiderivative of this polynomial.
 |      
 |      Notes
 |      -----
 |      If antiderivative is computed and ``self.extrapolate='periodic'``,
 |      it will be set to False for the returned instance. This is done because
 |      the antiderivative is no longer periodic and its correct evaluation
 |      outside of the initially given x interval is difficult.
 |  
 |  derivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the derivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of derivative to evaluate. Default is 1, i.e. compute the
 |          first derivative. If negative, the antiderivative is returned.
 |      
 |      Returns
 |      -------
 |      bp : BPoly
 |          Piecewise polynomial of order k - nu representing the derivative of
 |          this polynomial.
 |  
 |  extend(self, c, x, right=None)
 |      Add additional breakpoints and coefficients to the polynomial.
 |      
 |      Parameters
 |      ----------
 |      c : ndarray, size (k, m, ...)
 |          Additional coefficients for polynomials in intervals. Note that
 |          the first additional interval will be formed using one of the
 |          `self.x` end points.
 |      x : ndarray, size (m,)
 |          Additional breakpoints. Must be sorted in the same order as
 |          `self.x` and either to the right or to the left of the current
 |          breakpoints.
 |      right
 |          Deprecated argument. Has no effect.
 |      
 |          .. deprecated:: 0.19
 |  
 |  integrate(self, a, b, extrapolate=None)
 |      Compute a definite integral over a piecewise polynomial.
 |      
 |      Parameters
 |      ----------
 |      a : float
 |          Lower integration bound
 |      b : float
 |          Upper integration bound
 |      extrapolate : {bool, 'periodic', None}, optional
 |          Whether to extrapolate to out-of-bounds points based on first
 |          and last intervals, or to return NaNs. If 'periodic', periodic
 |          extrapolation is used. If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      array_like
 |          Definite integral of the piecewise polynomial over [a, b]
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_derivatives(xi, yi, orders=None, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial in the Bernstein basis,
 |      compatible with the specified values and derivatives at breakpoints.
 |      
 |      Parameters
 |      ----------
 |      xi : array_like
 |          sorted 1D array of x-coordinates
 |      yi : array_like or list of array_likes
 |          ``yi[i][j]`` is the ``j``-th derivative known at ``xi[i]``
 |      orders : None or int or array_like of ints. Default: None.
 |          Specifies the degree of local polynomials. If not None, some
 |          derivatives are ignored.
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |      
 |      Notes
 |      -----
 |      If ``k`` derivatives are specified at a breakpoint ``x``, the
 |      constructed polynomial is exactly ``k`` times continuously
 |      differentiable at ``x``, unless the ``order`` is provided explicitly.
 |      In the latter case, the smoothness of the polynomial at
 |      the breakpoint is controlled by the ``order``.
 |      
 |      Deduces the number of derivatives to match at each end
 |      from ``order`` and the number of derivatives available. If
 |      possible it uses the same number of derivatives from
 |      each end; if the number is odd it tries to take the
 |      extra one from y2. In any case if not enough derivatives
 |      are available at one end or another it draws enough to
 |      make up the total from the other end.
 |      
 |      If the order is too high and not enough derivatives are available,
 |      an exception is raised.
 |      
 |      Examples
 |      --------
 |      
 |      >>> from scipy.interpolate import BPoly
 |      >>> BPoly.from_derivatives([0, 1], [[1, 2], [3, 4]])
 |      
 |      Creates a polynomial `f(x)` of degree 3, defined on `[0, 1]`
 |      such that `f(0) = 1, df/dx(0) = 2, f(1) = 3, df/dx(1) = 4`
 |      
 |      >>> BPoly.from_derivatives([0, 1, 2], [[0, 1], [0], [2]])
 |      
 |      Creates a piecewise polynomial `f(x)`, such that
 |      `f(0) = f(1) = 0`, `f(2) = 2`, and `df/dx(0) = 1`.
 |      Based on the number of derivatives provided, the order of the
 |      local polynomials is 2 on `[0, 1]` and 1 on `[1, 2]`.
 |      Notice that no restriction is imposed on the derivatives at
 |      `x = 1` and `x = 2`.
 |      
 |      Indeed, the explicit form of the polynomial is::
 |      
 |          f(x) = | x * (1 - x),  0 <= x < 1
 |                 | 2 * (x - 1),  1 <= x <= 2
 |      
 |      So that f'(1-0) = -1 and f'(1+0) = 2
 |  
 |  from_power_basis(pp, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial in Bernstein basis
 |      from a power basis polynomial.
 |      
 |      Parameters
 |      ----------
 |      pp : PPoly
 |          A piecewise polynomial in the power basis
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _PPolyBase:
 |  
 |  __call__(self, x, nu=0, extrapolate=None)
 |      Evaluate the piecewise polynomial or its derivative.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      nu : int, optional
 |          Order of derivative to evaluate. Must be non-negative.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  __init__(self, c, x, extrapolate=None, axis=0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Class methods inherited from _PPolyBase:
 |  
 |  construct_fast(c, x, extrapolate=None, axis=0) from builtins.type
 |      Construct the piecewise polynomial without making checks.
 |      
 |      Takes the same parameters as the constructor. Input arguments
 |      `c` and `x` must be arrays of the correct shape and type.  The
 |      `c` array can only be of dtypes float and complex, and `x`
 |      array must have dtype float.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _PPolyBase:
 |  
 |  axis
 |  
 |  c
 |  
 |  extrapolate
 |  
 |  x
",class,"('(self, c, x, extrapolate=None, axis=0)',)",scipy,1.1.0,scipy.interpolate.interpolate.BPoly,interpolate.interpolate,BPoly,"Python Library Documentation: class BPoly in module scipy.interpolate.interpolate

class BPoly(_PPolyBase)
 |  Piecewise polynomial in terms of coefficients and breakpoints.
 |  
 |  The polynomial between ``x[i]`` and ``x[i + 1]`` is written in the
 |  Bernstein polynomial basis::
 |  
 |      S = sum(c[a, i] * b(a, k; x) for a in range(k+1)),
 |  
 |  where ``k`` is the degree of the polynomial, and::
 |  
 |      b(a, k; x) = binom(k, a) * t**a * (1 - t)**(k - a),
 |  
 |  with ``t = (x - x[i]) / (x[i+1] - x[i])`` and ``binom`` is the binomial
 |  coefficient.
 |  
 |  Parameters
 |  ----------
 |  c : ndarray, shape (k, m, ...)
 |      Polynomial coefficients, order `k` and `m` intervals
 |  x : ndarray, shape (m+1,)
 |      Polynomial breakpoints. Must be sorted in either increasing or
 |      decreasing order.
 |  extrapolate : bool, optional
 |      If bool, determines whether to extrapolate to out-of-bounds points
 |      based on first and last intervals, or to return NaNs. If 'periodic',
 |      periodic extrapolation is used. Default is True.
 |  axis : int, optional
 |      Interpolation axis. Default is zero.
 |  
 |  Attributes
 |  ----------
 |  x : ndarray
 |      Breakpoints.
 |  c : ndarray
 |      Coefficients of the polynomials. They are reshaped
 |      to a 3-dimensional array with the last dimension representing
 |      the trailing dimensions of the original coefficient array.
 |  axis : int
 |      Interpolation axis.
 |  
 |  Methods
 |  -------
 |  __call__
 |  extend
 |  derivative
 |  antiderivative
 |  integrate
 |  construct_fast
 |  from_power_basis
 |  from_derivatives
 |  
 |  See also
 |  --------
 |  PPoly : piecewise polynomials in the power basis
 |  
 |  Notes
 |  -----
 |  Properties of Bernstein polynomials are well documented in the literature.
 |  Here's a non-exhaustive list:
 |  
 |  .. [1] http://en.wikipedia.org/wiki/Bernstein_polynomial
 |  
 |  .. [2] Kenneth I. Joy, Bernstein polynomials,
 |    http://www.idav.ucdavis.edu/education/CAGDNotes/Bernstein-Polynomials.pdf
 |  
 |  .. [3] E. H. Doha, A. H. Bhrawy, and M. A. Saker, Boundary Value Problems,
 |       vol 2011, article ID 829546, :doi:`10.1155/2011/829543`.
 |  
 |  Examples
 |  --------
 |  >>> from scipy.interpolate import BPoly
 |  >>> x = [0, 1]
 |  >>> c = [[1], [2], [3]]
 |  >>> bp = BPoly(c, x)
 |  
 |  This creates a 2nd order polynomial
 |  
 |  .. math::
 |  
 |      B(x) = 1 \times b_{0, 2}(x) + 2 \times b_{1, 2}(x) + 3 \times b_{2, 2}(x) \\
 |           = 1 \times (1-x)^2 + 2 \times 2 x (1 - x) + 3 \times x^2
 |  
 |  Method resolution order:
 |      BPoly
 |      _PPolyBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  antiderivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the antiderivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of antiderivative to evaluate. Default is 1, i.e. compute
 |          the first integral. If negative, the derivative is returned.
 |      
 |      Returns
 |      -------
 |      bp : BPoly
 |          Piecewise polynomial of order k + nu representing the
 |          antiderivative of this polynomial.
 |      
 |      Notes
 |      -----
 |      If antiderivative is computed and ``self.extrapolate='periodic'``,
 |      it will be set to False for the returned instance. This is done because
 |      the antiderivative is no longer periodic and its correct evaluation
 |      outside of the initially given x interval is difficult.
 |  
 |  derivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the derivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of derivative to evaluate. Default is 1, i.e. compute the
 |          first derivative. If negative, the antiderivative is returned.
 |      
 |      Returns
 |      -------
 |      bp : BPoly
 |          Piecewise polynomial of order k - nu representing the derivative of
 |          this polynomial.
 |  
 |  extend(self, c, x, right=None)
 |      Add additional breakpoints and coefficients to the polynomial.
 |      
 |      Parameters
 |      ----------
 |      c : ndarray, size (k, m, ...)
 |          Additional coefficients for polynomials in intervals. Note that
 |          the first additional interval will be formed using one of the
 |          `self.x` end points.
 |      x : ndarray, size (m,)
 |          Additional breakpoints. Must be sorted in the same order as
 |          `self.x` and either to the right or to the left of the current
 |          breakpoints.
 |      right
 |          Deprecated argument. Has no effect.
 |      
 |          .. deprecated:: 0.19
 |  
 |  integrate(self, a, b, extrapolate=None)
 |      Compute a definite integral over a piecewise polynomial.
 |      
 |      Parameters
 |      ----------
 |      a : float
 |          Lower integration bound
 |      b : float
 |          Upper integration bound
 |      extrapolate : {bool, 'periodic', None}, optional
 |          Whether to extrapolate to out-of-bounds points based on first
 |          and last intervals, or to return NaNs. If 'periodic', periodic
 |          extrapolation is used. If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      array_like
 |          Definite integral of the piecewise polynomial over [a, b]
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_derivatives(xi, yi, orders=None, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial in the Bernstein basis,
 |      compatible with the specified values and derivatives at breakpoints.
 |      
 |      Parameters
 |      ----------
 |      xi : array_like
 |          sorted 1D array of x-coordinates
 |      yi : array_like or list of array_likes
 |          ``yi[i][j]`` is the ``j``-th derivative known at ``xi[i]``
 |      orders : None or int or array_like of ints. Default: None.
 |          Specifies the degree of local polynomials. If not None, some
 |          derivatives are ignored.
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |      
 |      Notes
 |      -----
 |      If ``k`` derivatives are specified at a breakpoint ``x``, the
 |      constructed polynomial is exactly ``k`` times continuously
 |      differentiable at ``x``, unless the ``order`` is provided explicitly.
 |      In the latter case, the smoothness of the polynomial at
 |      the breakpoint is controlled by the ``order``.
 |      
 |      Deduces the number of derivatives to match at each end
 |      from ``order`` and the number of derivatives available. If
 |      possible it uses the same number of derivatives from
 |      each end; if the number is odd it tries to take the
 |      extra one from y2. In any case if not enough derivatives
 |      are available at one end or another it draws enough to
 |      make up the total from the other end.
 |      
 |      If the order is too high and not enough derivatives are available,
 |      an exception is raised.
 |      
 |      Examples
 |      --------
 |      
 |      >>> from scipy.interpolate import BPoly
 |      >>> BPoly.from_derivatives([0, 1], [[1, 2], [3, 4]])
 |      
 |      Creates a polynomial `f(x)` of degree 3, defined on `[0, 1]`
 |      such that `f(0) = 1, df/dx(0) = 2, f(1) = 3, df/dx(1) = 4`
 |      
 |      >>> BPoly.from_derivatives([0, 1, 2], [[0, 1], [0], [2]])
 |      
 |      Creates a piecewise polynomial `f(x)`, such that
 |      `f(0) = f(1) = 0`, `f(2) = 2`, and `df/dx(0) = 1`.
 |      Based on the number of derivatives provided, the order of the
 |      local polynomials is 2 on `[0, 1]` and 1 on `[1, 2]`.
 |      Notice that no restriction is imposed on the derivatives at
 |      `x = 1` and `x = 2`.
 |      
 |      Indeed, the explicit form of the polynomial is::
 |      
 |          f(x) = | x * (1 - x),  0 <= x < 1
 |                 | 2 * (x - 1),  1 <= x <= 2
 |      
 |      So that f'(1-0) = -1 and f'(1+0) = 2
 |  
 |  from_power_basis(pp, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial in Bernstein basis
 |      from a power basis polynomial.
 |      
 |      Parameters
 |      ----------
 |      pp : PPoly
 |          A piecewise polynomial in the power basis
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _PPolyBase:
 |  
 |  __call__(self, x, nu=0, extrapolate=None)
 |      Evaluate the piecewise polynomial or its derivative.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      nu : int, optional
 |          Order of derivative to evaluate. Must be non-negative.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  __init__(self, c, x, extrapolate=None, axis=0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Class methods inherited from _PPolyBase:
 |  
 |  construct_fast(c, x, extrapolate=None, axis=0) from builtins.type
 |      Construct the piecewise polynomial without making checks.
 |      
 |      Takes the same parameters as the constructor. Input arguments
 |      `c` and `x` must be arrays of the correct shape and type.  The
 |      `c` array can only be of dtypes float and complex, and `x`
 |      array must have dtype float.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _PPolyBase:
 |  
 |  axis
 |  
 |  c
 |  
 |  extrapolate
 |  
 |  x
",class,"('self', 'c', 'x', 'extrapolate', 'axis')","(nan, nan, nan, None, 0)","(nan, nan, nan, 'NoneType', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, c, x, extrapolate=None, axis=0)',)"
scipy,1.1.0,scipy.interpolate.interpolate.BPoly.construct_fast,interpolate.interpolate.BPoly,construct_fast,"Python Library Documentation: method construct_fast in module scipy.interpolate.interpolate

construct_fast(c, x, extrapolate=None, axis=0) method of builtins.type instance
    Construct the piecewise polynomial without making checks.
    
    Takes the same parameters as the constructor. Input arguments
    `c` and `x` must be arrays of the correct shape and type.  The
    `c` array can only be of dtypes float and complex, and `x`
    array must have dtype float.
",method,"('(c, x, extrapolate=None, axis=0)',)",scipy,1.1.0,scipy.interpolate.interpolate.BPoly.construct_fast,interpolate.interpolate.BPoly,construct_fast,"Python Library Documentation: method construct_fast in module scipy.interpolate.interpolate

construct_fast(c, x, extrapolate=None, axis=0) method of builtins.type instance
    Construct the piecewise polynomial without making checks.
    
    Takes the same parameters as the constructor. Input arguments
    `c` and `x` must be arrays of the correct shape and type.  The
    `c` array can only be of dtypes float and complex, and `x`
    array must have dtype float.
",method,"('cls', 'c', 'x', 'extrapolate', 'axis')","(nan, nan, nan, None, 0)","(nan, nan, nan, 'NoneType', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(c, x, extrapolate=None, axis=0)',)"
scipy,1.1.0,scipy.interpolate.interpolate.BPoly.from_derivatives,interpolate.interpolate.BPoly,from_derivatives,"Python Library Documentation: method from_derivatives in module scipy.interpolate.interpolate

from_derivatives(xi, yi, orders=None, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial in the Bernstein basis,
    compatible with the specified values and derivatives at breakpoints.
    
    Parameters
    ----------
    xi : array_like
        sorted 1D array of x-coordinates
    yi : array_like or list of array_likes
        ``yi[i][j]`` is the ``j``-th derivative known at ``xi[i]``
    orders : None or int or array_like of ints. Default: None.
        Specifies the degree of local polynomials. If not None, some
        derivatives are ignored.
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
    
    Notes
    -----
    If ``k`` derivatives are specified at a breakpoint ``x``, the
    constructed polynomial is exactly ``k`` times continuously
    differentiable at ``x``, unless the ``order`` is provided explicitly.
    In the latter case, the smoothness of the polynomial at
    the breakpoint is controlled by the ``order``.
    
    Deduces the number of derivatives to match at each end
    from ``order`` and the number of derivatives available. If
    possible it uses the same number of derivatives from
    each end; if the number is odd it tries to take the
    extra one from y2. In any case if not enough derivatives
    are available at one end or another it draws enough to
    make up the total from the other end.
    
    If the order is too high and not enough derivatives are available,
    an exception is raised.
    
    Examples
    --------
    
    >>> from scipy.interpolate import BPoly
    >>> BPoly.from_derivatives([0, 1], [[1, 2], [3, 4]])
    
    Creates a polynomial `f(x)` of degree 3, defined on `[0, 1]`
    such that `f(0) = 1, df/dx(0) = 2, f(1) = 3, df/dx(1) = 4`
    
    >>> BPoly.from_derivatives([0, 1, 2], [[0, 1], [0], [2]])
    
    Creates a piecewise polynomial `f(x)`, such that
    `f(0) = f(1) = 0`, `f(2) = 2`, and `df/dx(0) = 1`.
    Based on the number of derivatives provided, the order of the
    local polynomials is 2 on `[0, 1]` and 1 on `[1, 2]`.
    Notice that no restriction is imposed on the derivatives at
    `x = 1` and `x = 2`.
    
    Indeed, the explicit form of the polynomial is::
    
        f(x) = | x * (1 - x),  0 <= x < 1
               | 2 * (x - 1),  1 <= x <= 2
    
    So that f'(1-0) = -1 and f'(1+0) = 2
",method,"('(xi, yi, orders=None, extrapolate=None)',)",scipy,1.1.0,scipy.interpolate.interpolate.BPoly.from_derivatives,interpolate.interpolate.BPoly,from_derivatives,"Python Library Documentation: method from_derivatives in module scipy.interpolate.interpolate

from_derivatives(xi, yi, orders=None, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial in the Bernstein basis,
    compatible with the specified values and derivatives at breakpoints.
    
    Parameters
    ----------
    xi : array_like
        sorted 1D array of x-coordinates
    yi : array_like or list of array_likes
        ``yi[i][j]`` is the ``j``-th derivative known at ``xi[i]``
    orders : None or int or array_like of ints. Default: None.
        Specifies the degree of local polynomials. If not None, some
        derivatives are ignored.
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
    
    Notes
    -----
    If ``k`` derivatives are specified at a breakpoint ``x``, the
    constructed polynomial is exactly ``k`` times continuously
    differentiable at ``x``, unless the ``order`` is provided explicitly.
    In the latter case, the smoothness of the polynomial at
    the breakpoint is controlled by the ``order``.
    
    Deduces the number of derivatives to match at each end
    from ``order`` and the number of derivatives available. If
    possible it uses the same number of derivatives from
    each end; if the number is odd it tries to take the
    extra one from y2. In any case if not enough derivatives
    are available at one end or another it draws enough to
    make up the total from the other end.
    
    If the order is too high and not enough derivatives are available,
    an exception is raised.
    
    Examples
    --------
    
    >>> from scipy.interpolate import BPoly
    >>> BPoly.from_derivatives([0, 1], [[1, 2], [3, 4]])
    
    Creates a polynomial `f(x)` of degree 3, defined on `[0, 1]`
    such that `f(0) = 1, df/dx(0) = 2, f(1) = 3, df/dx(1) = 4`
    
    >>> BPoly.from_derivatives([0, 1, 2], [[0, 1], [0], [2]])
    
    Creates a piecewise polynomial `f(x)`, such that
    `f(0) = f(1) = 0`, `f(2) = 2`, and `df/dx(0) = 1`.
    Based on the number of derivatives provided, the order of the
    local polynomials is 2 on `[0, 1]` and 1 on `[1, 2]`.
    Notice that no restriction is imposed on the derivatives at
    `x = 1` and `x = 2`.
    
    Indeed, the explicit form of the polynomial is::
    
        f(x) = | x * (1 - x),  0 <= x < 1
               | 2 * (x - 1),  1 <= x <= 2
    
    So that f'(1-0) = -1 and f'(1+0) = 2
",method,"('cls', 'xi', 'yi', 'orders', 'extrapolate')","(nan, nan, nan, None, None)","(nan, nan, nan, 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(xi, yi, orders=None, extrapolate=None)',)"
scipy,1.1.0,scipy.interpolate.interpolate.BPoly.from_power_basis,interpolate.interpolate.BPoly,from_power_basis,"Python Library Documentation: method from_power_basis in module scipy.interpolate.interpolate

from_power_basis(pp, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial in Bernstein basis
    from a power basis polynomial.
    
    Parameters
    ----------
    pp : PPoly
        A piecewise polynomial in the power basis
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
",method,"('(pp, extrapolate=None)',)",scipy,1.1.0,scipy.interpolate.interpolate.BPoly.from_power_basis,interpolate.interpolate.BPoly,from_power_basis,"Python Library Documentation: method from_power_basis in module scipy.interpolate.interpolate

from_power_basis(pp, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial in Bernstein basis
    from a power basis polynomial.
    
    Parameters
    ----------
    pp : PPoly
        A piecewise polynomial in the power basis
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
",method,"('cls', 'pp', 'extrapolate')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(pp, extrapolate=None)',)"
scipy,1.1.0,scipy.interpolate.interpolate.BSpline,interpolate.interpolate,BSpline,"Python Library Documentation: class BSpline in module scipy.interpolate._bsplines

class BSpline(builtins.object)
 |  Univariate spline in the B-spline basis.
 |  
 |  .. math::
 |  
 |      S(x) = \sum_{j=0}^{n-1} c_j  B_{j, k; t}(x)
 |  
 |  where :math:`B_{j, k; t}` are B-spline basis functions of degree `k`
 |  and knots `t`.
 |  
 |  Parameters
 |  ----------
 |  t : ndarray, shape (n+k+1,)
 |      knots
 |  c : ndarray, shape (>=n, ...)
 |      spline coefficients
 |  k : int
 |      B-spline order
 |  extrapolate : bool or 'periodic', optional
 |      whether to extrapolate beyond the base interval, ``t[k] .. t[n]``,
 |      or to return nans.
 |      If True, extrapolates the first and last polynomial pieces of b-spline
 |      functions active on the base interval.
 |      If 'periodic', periodic extrapolation is used.
 |      Default is True.
 |  axis : int, optional
 |      Interpolation axis. Default is zero.
 |  
 |  Attributes
 |  ----------
 |  t : ndarray
 |      knot vector
 |  c : ndarray
 |      spline coefficients
 |  k : int
 |      spline degree
 |  extrapolate : bool
 |      If True, extrapolates the first and last polynomial pieces of b-spline
 |      functions active on the base interval.
 |  axis : int
 |      Interpolation axis.
 |  tck : tuple
 |      A read-only equivalent of ``(self.t, self.c, self.k)``
 |  
 |  Methods
 |  -------
 |  __call__
 |  basis_element
 |  derivative
 |  antiderivative
 |  integrate
 |  construct_fast
 |  
 |  Notes
 |  -----
 |  B-spline basis elements are defined via
 |  
 |  .. math::
 |  
 |      B_{i, 0}(x) = 1, \textrm{if $t_i \le x < t_{i+1}$, otherwise $0$,}
 |  
 |      B_{i, k}(x) = \frac{x - t_i}{t_{i+k} - t_i} B_{i, k-1}(x)
 |               + \frac{t_{i+k+1} - x}{t_{i+k+1} - t_{i+1}} B_{i+1, k-1}(x)
 |  
 |  **Implementation details**
 |  
 |  - At least ``k+1`` coefficients are required for a spline of degree `k`,
 |    so that ``n >= k+1``. Additional coefficients, ``c[j]`` with
 |    ``j > n``, are ignored.
 |  
 |  - B-spline basis elements of degree `k` form a partition of unity on the
 |    *base interval*, ``t[k] <= x <= t[n]``.
 |  
 |  
 |  Examples
 |  --------
 |  
 |  Translating the recursive definition of B-splines into Python code, we have:
 |  
 |  >>> def B(x, k, i, t):
 |  ...    if k == 0:
 |  ...       return 1.0 if t[i] <= x < t[i+1] else 0.0
 |  ...    if t[i+k] == t[i]:
 |  ...       c1 = 0.0
 |  ...    else:
 |  ...       c1 = (x - t[i])/(t[i+k] - t[i]) * B(x, k-1, i, t)
 |  ...    if t[i+k+1] == t[i+1]:
 |  ...       c2 = 0.0
 |  ...    else:
 |  ...       c2 = (t[i+k+1] - x)/(t[i+k+1] - t[i+1]) * B(x, k-1, i+1, t)
 |  ...    return c1 + c2
 |  
 |  >>> def bspline(x, t, c, k):
 |  ...    n = len(t) - k - 1
 |  ...    assert (n >= k+1) and (len(c) >= n)
 |  ...    return sum(c[i] * B(x, k, i, t) for i in range(n))
 |  
 |  Note that this is an inefficient (if straightforward) way to
 |  evaluate B-splines --- this spline class does it in an equivalent,
 |  but much more efficient way.
 |  
 |  Here we construct a quadratic spline function on the base interval
 |  ``2 <= x <= 4`` and compare with the naive way of evaluating the spline:
 |  
 |  >>> from scipy.interpolate import BSpline
 |  >>> k = 2
 |  >>> t = [0, 1, 2, 3, 4, 5, 6]
 |  >>> c = [-1, 2, 0, -1]
 |  >>> spl = BSpline(t, c, k)
 |  >>> spl(2.5)
 |  array(1.375)
 |  >>> bspline(2.5, t, c, k)
 |  1.375
 |  
 |  Note that outside of the base interval results differ. This is because
 |  `BSpline` extrapolates the first and last polynomial pieces of b-spline
 |  functions active on the base interval.
 |  
 |  >>> import matplotlib.pyplot as plt
 |  >>> fig, ax = plt.subplots()
 |  >>> xx = np.linspace(1.5, 4.5, 50)
 |  >>> ax.plot(xx, [bspline(x, t, c ,k) for x in xx], 'r-', lw=3, label='naive')
 |  >>> ax.plot(xx, spl(xx), 'b-', lw=4, alpha=0.7, label='BSpline')
 |  >>> ax.grid(True)
 |  >>> ax.legend(loc='best')
 |  >>> plt.show()
 |  
 |  
 |  References
 |  ----------
 |  .. [1] Tom Lyche and Knut Morken, Spline methods,
 |      http://www.uio.no/studier/emner/matnat/ifi/INF-MAT5340/v05/undervisningsmateriale/
 |  .. [2] Carl de Boor, A practical guide to splines, Springer, 2001.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, x, nu=0, extrapolate=None)
 |      Evaluate a spline function.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          points to evaluate the spline at.
 |      nu: int, optional
 |          derivative to evaluate (default is 0).
 |      extrapolate : bool or 'periodic', optional
 |          whether to extrapolate based on the first and last intervals
 |          or return nans. If 'periodic', periodic extrapolation is used.
 |          Default is `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Shape is determined by replacing the interpolation axis
 |          in the coefficient array with the shape of `x`.
 |  
 |  __init__(self, t, c, k, extrapolate=True, axis=0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  antiderivative(self, nu=1)
 |      Return a b-spline representing the antiderivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Antiderivative order. Default is 1.
 |      
 |      Returns
 |      -------
 |      b : BSpline object
 |          A new instance representing the antiderivative.
 |      
 |      Notes
 |      -----
 |      If antiderivative is computed and ``self.extrapolate='periodic'``,
 |      it will be set to False for the returned instance. This is done because
 |      the antiderivative is no longer periodic and its correct evaluation
 |      outside of the initially given x interval is difficult.
 |      
 |      See Also
 |      --------
 |      splder, splantider
 |  
 |  derivative(self, nu=1)
 |      Return a b-spline representing the derivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Derivative order.
 |          Default is 1.
 |      
 |      Returns
 |      -------
 |      b : BSpline object
 |          A new instance representing the derivative.
 |      
 |      See Also
 |      --------
 |      splder, splantider
 |  
 |  integrate(self, a, b, extrapolate=None)
 |      Compute a definite integral of the spline.
 |      
 |      Parameters
 |      ----------
 |      a : float
 |          Lower limit of integration.
 |      b : float
 |          Upper limit of integration.
 |      extrapolate : bool or 'periodic', optional
 |          whether to extrapolate beyond the base interval,
 |          ``t[k] .. t[-k-1]``, or take the spline to be zero outside of the
 |          base interval. If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      I : array_like
 |          Definite integral of the spline over the interval ``[a, b]``.
 |      
 |      Examples
 |      --------
 |      Construct the linear spline ``x if x < 1 else 2 - x`` on the base
 |      interval :math:`[0, 2]`, and integrate it
 |      
 |      >>> from scipy.interpolate import BSpline
 |      >>> b = BSpline.basis_element([0, 1, 2])
 |      >>> b.integrate(0, 1)
 |      array(0.5)
 |      
 |      If the integration limits are outside of the base interval, the result
 |      is controlled by the `extrapolate` parameter
 |      
 |      >>> b.integrate(-1, 1)
 |      array(0.0)
 |      >>> b.integrate(-1, 1, extrapolate=False)
 |      array(0.5)
 |      
 |      >>> import matplotlib.pyplot as plt
 |      >>> fig, ax = plt.subplots()
 |      >>> ax.grid(True)
 |      >>> ax.axvline(0, c='r', lw=5, alpha=0.5)  # base interval
 |      >>> ax.axvline(2, c='r', lw=5, alpha=0.5)
 |      >>> xx = [-1, 1, 2]
 |      >>> ax.plot(xx, b(xx))
 |      >>> plt.show()
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  basis_element(t, extrapolate=True) from builtins.type
 |      Return a B-spline basis element ``B(x | t[0], ..., t[k+1])``.
 |      
 |      Parameters
 |      ----------
 |      t : ndarray, shape (k+1,)
 |          internal knots
 |      extrapolate : bool or 'periodic', optional
 |          whether to extrapolate beyond the base interval, ``t[0] .. t[k+1]``,
 |          or to return nans.
 |          If 'periodic', periodic extrapolation is used.
 |          Default is True.
 |      
 |      Returns
 |      -------
 |      basis_element : callable
 |          A callable representing a B-spline basis element for the knot
 |          vector `t`.
 |      
 |      Notes
 |      -----
 |      The order of the b-spline, `k`, is inferred from the length of `t` as
 |      ``len(t)-2``. The knot vector is constructed by appending and prepending
 |      ``k+1`` elements to internal knots `t`.
 |      
 |      Examples
 |      --------
 |      
 |      Construct a cubic b-spline:
 |      
 |      >>> from scipy.interpolate import BSpline
 |      >>> b = BSpline.basis_element([0, 1, 2, 3, 4])
 |      >>> k = b.k
 |      >>> b.t[k:-k]
 |      array([ 0.,  1.,  2.,  3.,  4.])
 |      >>> k
 |      3
 |      
 |      Construct a second order b-spline on ``[0, 1, 1, 2]``, and compare
 |      to its explicit form:
 |      
 |      >>> t = [-1, 0, 1, 1, 2]
 |      >>> b = BSpline.basis_element(t[1:])
 |      >>> def f(x):
 |      ...     return np.where(x < 1, x*x, (2. - x)**2)
 |      
 |      >>> import matplotlib.pyplot as plt
 |      >>> fig, ax = plt.subplots()
 |      >>> x = np.linspace(0, 2, 51)
 |      >>> ax.plot(x, b(x), 'g', lw=3)
 |      >>> ax.plot(x, f(x), 'r', lw=8, alpha=0.4)
 |      >>> ax.grid(True)
 |      >>> plt.show()
 |  
 |  construct_fast(t, c, k, extrapolate=True, axis=0) from builtins.type
 |      Construct a spline without making checks.
 |      
 |      Accepts same parameters as the regular constructor. Input arrays
 |      `t` and `c` must of correct shape and dtype.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  tck
 |      Equivalent to ``(self.t, self.c, self.k)`` (read-only).
",class,"('(self, t, c, k, extrapolate=True, axis=0)',)",scipy,1.1.0,scipy.interpolate.interpolate.BSpline,interpolate.interpolate,BSpline,"Python Library Documentation: class BSpline in module scipy.interpolate._bsplines

class BSpline(builtins.object)
 |  Univariate spline in the B-spline basis.
 |  
 |  .. math::
 |  
 |      S(x) = \sum_{j=0}^{n-1} c_j  B_{j, k; t}(x)
 |  
 |  where :math:`B_{j, k; t}` are B-spline basis functions of degree `k`
 |  and knots `t`.
 |  
 |  Parameters
 |  ----------
 |  t : ndarray, shape (n+k+1,)
 |      knots
 |  c : ndarray, shape (>=n, ...)
 |      spline coefficients
 |  k : int
 |      B-spline order
 |  extrapolate : bool or 'periodic', optional
 |      whether to extrapolate beyond the base interval, ``t[k] .. t[n]``,
 |      or to return nans.
 |      If True, extrapolates the first and last polynomial pieces of b-spline
 |      functions active on the base interval.
 |      If 'periodic', periodic extrapolation is used.
 |      Default is True.
 |  axis : int, optional
 |      Interpolation axis. Default is zero.
 |  
 |  Attributes
 |  ----------
 |  t : ndarray
 |      knot vector
 |  c : ndarray
 |      spline coefficients
 |  k : int
 |      spline degree
 |  extrapolate : bool
 |      If True, extrapolates the first and last polynomial pieces of b-spline
 |      functions active on the base interval.
 |  axis : int
 |      Interpolation axis.
 |  tck : tuple
 |      A read-only equivalent of ``(self.t, self.c, self.k)``
 |  
 |  Methods
 |  -------
 |  __call__
 |  basis_element
 |  derivative
 |  antiderivative
 |  integrate
 |  construct_fast
 |  
 |  Notes
 |  -----
 |  B-spline basis elements are defined via
 |  
 |  .. math::
 |  
 |      B_{i, 0}(x) = 1, \textrm{if $t_i \le x < t_{i+1}$, otherwise $0$,}
 |  
 |      B_{i, k}(x) = \frac{x - t_i}{t_{i+k} - t_i} B_{i, k-1}(x)
 |               + \frac{t_{i+k+1} - x}{t_{i+k+1} - t_{i+1}} B_{i+1, k-1}(x)
 |  
 |  **Implementation details**
 |  
 |  - At least ``k+1`` coefficients are required for a spline of degree `k`,
 |    so that ``n >= k+1``. Additional coefficients, ``c[j]`` with
 |    ``j > n``, are ignored.
 |  
 |  - B-spline basis elements of degree `k` form a partition of unity on the
 |    *base interval*, ``t[k] <= x <= t[n]``.
 |  
 |  
 |  Examples
 |  --------
 |  
 |  Translating the recursive definition of B-splines into Python code, we have:
 |  
 |  >>> def B(x, k, i, t):
 |  ...    if k == 0:
 |  ...       return 1.0 if t[i] <= x < t[i+1] else 0.0
 |  ...    if t[i+k] == t[i]:
 |  ...       c1 = 0.0
 |  ...    else:
 |  ...       c1 = (x - t[i])/(t[i+k] - t[i]) * B(x, k-1, i, t)
 |  ...    if t[i+k+1] == t[i+1]:
 |  ...       c2 = 0.0
 |  ...    else:
 |  ...       c2 = (t[i+k+1] - x)/(t[i+k+1] - t[i+1]) * B(x, k-1, i+1, t)
 |  ...    return c1 + c2
 |  
 |  >>> def bspline(x, t, c, k):
 |  ...    n = len(t) - k - 1
 |  ...    assert (n >= k+1) and (len(c) >= n)
 |  ...    return sum(c[i] * B(x, k, i, t) for i in range(n))
 |  
 |  Note that this is an inefficient (if straightforward) way to
 |  evaluate B-splines --- this spline class does it in an equivalent,
 |  but much more efficient way.
 |  
 |  Here we construct a quadratic spline function on the base interval
 |  ``2 <= x <= 4`` and compare with the naive way of evaluating the spline:
 |  
 |  >>> from scipy.interpolate import BSpline
 |  >>> k = 2
 |  >>> t = [0, 1, 2, 3, 4, 5, 6]
 |  >>> c = [-1, 2, 0, -1]
 |  >>> spl = BSpline(t, c, k)
 |  >>> spl(2.5)
 |  array(1.375)
 |  >>> bspline(2.5, t, c, k)
 |  1.375
 |  
 |  Note that outside of the base interval results differ. This is because
 |  `BSpline` extrapolates the first and last polynomial pieces of b-spline
 |  functions active on the base interval.
 |  
 |  >>> import matplotlib.pyplot as plt
 |  >>> fig, ax = plt.subplots()
 |  >>> xx = np.linspace(1.5, 4.5, 50)
 |  >>> ax.plot(xx, [bspline(x, t, c ,k) for x in xx], 'r-', lw=3, label='naive')
 |  >>> ax.plot(xx, spl(xx), 'b-', lw=4, alpha=0.7, label='BSpline')
 |  >>> ax.grid(True)
 |  >>> ax.legend(loc='best')
 |  >>> plt.show()
 |  
 |  
 |  References
 |  ----------
 |  .. [1] Tom Lyche and Knut Morken, Spline methods,
 |      http://www.uio.no/studier/emner/matnat/ifi/INF-MAT5340/v05/undervisningsmateriale/
 |  .. [2] Carl de Boor, A practical guide to splines, Springer, 2001.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, x, nu=0, extrapolate=None)
 |      Evaluate a spline function.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          points to evaluate the spline at.
 |      nu: int, optional
 |          derivative to evaluate (default is 0).
 |      extrapolate : bool or 'periodic', optional
 |          whether to extrapolate based on the first and last intervals
 |          or return nans. If 'periodic', periodic extrapolation is used.
 |          Default is `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Shape is determined by replacing the interpolation axis
 |          in the coefficient array with the shape of `x`.
 |  
 |  __init__(self, t, c, k, extrapolate=True, axis=0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  antiderivative(self, nu=1)
 |      Return a b-spline representing the antiderivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Antiderivative order. Default is 1.
 |      
 |      Returns
 |      -------
 |      b : BSpline object
 |          A new instance representing the antiderivative.
 |      
 |      Notes
 |      -----
 |      If antiderivative is computed and ``self.extrapolate='periodic'``,
 |      it will be set to False for the returned instance. This is done because
 |      the antiderivative is no longer periodic and its correct evaluation
 |      outside of the initially given x interval is difficult.
 |      
 |      See Also
 |      --------
 |      splder, splantider
 |  
 |  derivative(self, nu=1)
 |      Return a b-spline representing the derivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Derivative order.
 |          Default is 1.
 |      
 |      Returns
 |      -------
 |      b : BSpline object
 |          A new instance representing the derivative.
 |      
 |      See Also
 |      --------
 |      splder, splantider
 |  
 |  integrate(self, a, b, extrapolate=None)
 |      Compute a definite integral of the spline.
 |      
 |      Parameters
 |      ----------
 |      a : float
 |          Lower limit of integration.
 |      b : float
 |          Upper limit of integration.
 |      extrapolate : bool or 'periodic', optional
 |          whether to extrapolate beyond the base interval,
 |          ``t[k] .. t[-k-1]``, or take the spline to be zero outside of the
 |          base interval. If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      I : array_like
 |          Definite integral of the spline over the interval ``[a, b]``.
 |      
 |      Examples
 |      --------
 |      Construct the linear spline ``x if x < 1 else 2 - x`` on the base
 |      interval :math:`[0, 2]`, and integrate it
 |      
 |      >>> from scipy.interpolate import BSpline
 |      >>> b = BSpline.basis_element([0, 1, 2])
 |      >>> b.integrate(0, 1)
 |      array(0.5)
 |      
 |      If the integration limits are outside of the base interval, the result
 |      is controlled by the `extrapolate` parameter
 |      
 |      >>> b.integrate(-1, 1)
 |      array(0.0)
 |      >>> b.integrate(-1, 1, extrapolate=False)
 |      array(0.5)
 |      
 |      >>> import matplotlib.pyplot as plt
 |      >>> fig, ax = plt.subplots()
 |      >>> ax.grid(True)
 |      >>> ax.axvline(0, c='r', lw=5, alpha=0.5)  # base interval
 |      >>> ax.axvline(2, c='r', lw=5, alpha=0.5)
 |      >>> xx = [-1, 1, 2]
 |      >>> ax.plot(xx, b(xx))
 |      >>> plt.show()
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  basis_element(t, extrapolate=True) from builtins.type
 |      Return a B-spline basis element ``B(x | t[0], ..., t[k+1])``.
 |      
 |      Parameters
 |      ----------
 |      t : ndarray, shape (k+1,)
 |          internal knots
 |      extrapolate : bool or 'periodic', optional
 |          whether to extrapolate beyond the base interval, ``t[0] .. t[k+1]``,
 |          or to return nans.
 |          If 'periodic', periodic extrapolation is used.
 |          Default is True.
 |      
 |      Returns
 |      -------
 |      basis_element : callable
 |          A callable representing a B-spline basis element for the knot
 |          vector `t`.
 |      
 |      Notes
 |      -----
 |      The order of the b-spline, `k`, is inferred from the length of `t` as
 |      ``len(t)-2``. The knot vector is constructed by appending and prepending
 |      ``k+1`` elements to internal knots `t`.
 |      
 |      Examples
 |      --------
 |      
 |      Construct a cubic b-spline:
 |      
 |      >>> from scipy.interpolate import BSpline
 |      >>> b = BSpline.basis_element([0, 1, 2, 3, 4])
 |      >>> k = b.k
 |      >>> b.t[k:-k]
 |      array([ 0.,  1.,  2.,  3.,  4.])
 |      >>> k
 |      3
 |      
 |      Construct a second order b-spline on ``[0, 1, 1, 2]``, and compare
 |      to its explicit form:
 |      
 |      >>> t = [-1, 0, 1, 1, 2]
 |      >>> b = BSpline.basis_element(t[1:])
 |      >>> def f(x):
 |      ...     return np.where(x < 1, x*x, (2. - x)**2)
 |      
 |      >>> import matplotlib.pyplot as plt
 |      >>> fig, ax = plt.subplots()
 |      >>> x = np.linspace(0, 2, 51)
 |      >>> ax.plot(x, b(x), 'g', lw=3)
 |      >>> ax.plot(x, f(x), 'r', lw=8, alpha=0.4)
 |      >>> ax.grid(True)
 |      >>> plt.show()
 |  
 |  construct_fast(t, c, k, extrapolate=True, axis=0) from builtins.type
 |      Construct a spline without making checks.
 |      
 |      Accepts same parameters as the regular constructor. Input arrays
 |      `t` and `c` must of correct shape and dtype.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  tck
 |      Equivalent to ``(self.t, self.c, self.k)`` (read-only).
",class,"('self', 't', 'c', 'k', 'extrapolate', 'axis')","(nan, nan, nan, nan, True, 0)","(nan, nan, nan, nan, 'bool', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, t, c, k, extrapolate=True, axis=0)',)"
scipy,1.1.0,scipy.interpolate.interpolate.BSpline.basis_element,interpolate.interpolate.BSpline,basis_element,"Python Library Documentation: method basis_element in module scipy.interpolate._bsplines

basis_element(t, extrapolate=True) method of builtins.type instance
    Return a B-spline basis element ``B(x | t[0], ..., t[k+1])``.
    
    Parameters
    ----------
    t : ndarray, shape (k+1,)
        internal knots
    extrapolate : bool or 'periodic', optional
        whether to extrapolate beyond the base interval, ``t[0] .. t[k+1]``,
        or to return nans.
        If 'periodic', periodic extrapolation is used.
        Default is True.
    
    Returns
    -------
    basis_element : callable
        A callable representing a B-spline basis element for the knot
        vector `t`.
    
    Notes
    -----
    The order of the b-spline, `k`, is inferred from the length of `t` as
    ``len(t)-2``. The knot vector is constructed by appending and prepending
    ``k+1`` elements to internal knots `t`.
    
    Examples
    --------
    
    Construct a cubic b-spline:
    
    >>> from scipy.interpolate import BSpline
    >>> b = BSpline.basis_element([0, 1, 2, 3, 4])
    >>> k = b.k
    >>> b.t[k:-k]
    array([ 0.,  1.,  2.,  3.,  4.])
    >>> k
    3
    
    Construct a second order b-spline on ``[0, 1, 1, 2]``, and compare
    to its explicit form:
    
    >>> t = [-1, 0, 1, 1, 2]
    >>> b = BSpline.basis_element(t[1:])
    >>> def f(x):
    ...     return np.where(x < 1, x*x, (2. - x)**2)
    
    >>> import matplotlib.pyplot as plt
    >>> fig, ax = plt.subplots()
    >>> x = np.linspace(0, 2, 51)
    >>> ax.plot(x, b(x), 'g', lw=3)
    >>> ax.plot(x, f(x), 'r', lw=8, alpha=0.4)
    >>> ax.grid(True)
    >>> plt.show()
",method,"('(t, extrapolate=True)',)",scipy,1.1.0,scipy.interpolate.interpolate.BSpline.basis_element,interpolate.interpolate.BSpline,basis_element,"Python Library Documentation: method basis_element in module scipy.interpolate._bsplines

basis_element(t, extrapolate=True) method of builtins.type instance
    Return a B-spline basis element ``B(x | t[0], ..., t[k+1])``.
    
    Parameters
    ----------
    t : ndarray, shape (k+1,)
        internal knots
    extrapolate : bool or 'periodic', optional
        whether to extrapolate beyond the base interval, ``t[0] .. t[k+1]``,
        or to return nans.
        If 'periodic', periodic extrapolation is used.
        Default is True.
    
    Returns
    -------
    basis_element : callable
        A callable representing a B-spline basis element for the knot
        vector `t`.
    
    Notes
    -----
    The order of the b-spline, `k`, is inferred from the length of `t` as
    ``len(t)-2``. The knot vector is constructed by appending and prepending
    ``k+1`` elements to internal knots `t`.
    
    Examples
    --------
    
    Construct a cubic b-spline:
    
    >>> from scipy.interpolate import BSpline
    >>> b = BSpline.basis_element([0, 1, 2, 3, 4])
    >>> k = b.k
    >>> b.t[k:-k]
    array([ 0.,  1.,  2.,  3.,  4.])
    >>> k
    3
    
    Construct a second order b-spline on ``[0, 1, 1, 2]``, and compare
    to its explicit form:
    
    >>> t = [-1, 0, 1, 1, 2]
    >>> b = BSpline.basis_element(t[1:])
    >>> def f(x):
    ...     return np.where(x < 1, x*x, (2. - x)**2)
    
    >>> import matplotlib.pyplot as plt
    >>> fig, ax = plt.subplots()
    >>> x = np.linspace(0, 2, 51)
    >>> ax.plot(x, b(x), 'g', lw=3)
    >>> ax.plot(x, f(x), 'r', lw=8, alpha=0.4)
    >>> ax.grid(True)
    >>> plt.show()
",method,"('cls', 't', 'extrapolate')","(nan, nan, True)","(nan, nan, 'bool')","('arg_info', 'arg_info', 'arg_info')","('(t, extrapolate=True)',)"
scipy,1.1.0,scipy.interpolate.interpolate.BSpline.construct_fast,interpolate.interpolate.BSpline,construct_fast,"Python Library Documentation: method construct_fast in module scipy.interpolate._bsplines

construct_fast(t, c, k, extrapolate=True, axis=0) method of builtins.type instance
    Construct a spline without making checks.
    
    Accepts same parameters as the regular constructor. Input arrays
    `t` and `c` must of correct shape and dtype.
",method,"('(t, c, k, extrapolate=True, axis=0)',)",scipy,1.1.0,scipy.interpolate.interpolate.BSpline.construct_fast,interpolate.interpolate.BSpline,construct_fast,"Python Library Documentation: method construct_fast in module scipy.interpolate._bsplines

construct_fast(t, c, k, extrapolate=True, axis=0) method of builtins.type instance
    Construct a spline without making checks.
    
    Accepts same parameters as the regular constructor. Input arrays
    `t` and `c` must of correct shape and dtype.
",method,"('cls', 't', 'c', 'k', 'extrapolate', 'axis')","(nan, nan, nan, nan, True, 0)","(nan, nan, nan, nan, 'bool', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(t, c, k, extrapolate=True, axis=0)',)"
scipy,1.1.0,scipy.interpolate.interpolate.NdPPoly,interpolate.interpolate,NdPPoly,"Python Library Documentation: class NdPPoly in module scipy.interpolate.interpolate

class NdPPoly(builtins.object)
 |  Piecewise tensor product polynomial
 |  
 |  The value at point `xp = (x', y', z', ...)` is evaluated by first
 |  computing the interval indices `i` such that::
 |  
 |      x[0][i[0]] <= x' < x[0][i[0]+1]
 |      x[1][i[1]] <= y' < x[1][i[1]+1]
 |      ...
 |  
 |  and then computing::
 |  
 |      S = sum(c[k0-m0-1,...,kn-mn-1,i[0],...,i[n]]
 |              * (xp[0] - x[0][i[0]])**m0
 |              * ...
 |              * (xp[n] - x[n][i[n]])**mn
 |              for m0 in range(k[0]+1)
 |              ...
 |              for mn in range(k[n]+1))
 |  
 |  where ``k[j]`` is the degree of the polynomial in dimension j. This
 |  representation is the piecewise multivariate power basis.
 |  
 |  Parameters
 |  ----------
 |  c : ndarray, shape (k0, ..., kn, m0, ..., mn, ...)
 |      Polynomial coefficients, with polynomial order `kj` and
 |      `mj+1` intervals for each dimension `j`.
 |  x : ndim-tuple of ndarrays, shapes (mj+1,)
 |      Polynomial breakpoints for each dimension. These must be
 |      sorted in increasing order.
 |  extrapolate : bool, optional
 |      Whether to extrapolate to out-of-bounds points based on first
 |      and last intervals, or to return NaNs. Default: True.
 |  
 |  Attributes
 |  ----------
 |  x : tuple of ndarrays
 |      Breakpoints.
 |  c : ndarray
 |      Coefficients of the polynomials.
 |  
 |  Methods
 |  -------
 |  __call__
 |  construct_fast
 |  
 |  See also
 |  --------
 |  PPoly : piecewise polynomials in 1D
 |  
 |  Notes
 |  -----
 |  High-order polynomials in the power basis can be numerically
 |  unstable.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, x, nu=None, extrapolate=None)
 |      Evaluate the piecewise polynomial or its derivative
 |      
 |      Parameters
 |      ----------
 |      x : array-like
 |          Points to evaluate the interpolant at.
 |      nu : tuple, optional
 |          Orders of derivatives to evaluate. Each must be non-negative.
 |      extrapolate : bool, optional
 |          Whether to extrapolate to out-of-bounds points based on first
 |          and last intervals, or to return NaNs.
 |      
 |      Returns
 |      -------
 |      y : array-like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  __init__(self, c, x, extrapolate=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  antiderivative(self, nu)
 |      Construct a new piecewise polynomial representing the antiderivative.
 |      
 |      Antiderivative is also the indefinite integral of the function,
 |      and derivative is its inverse operation.
 |      
 |      Parameters
 |      ----------
 |      nu : ndim-tuple of int
 |          Order of derivatives to evaluate for each dimension.
 |          If negative, the derivative is returned.
 |      
 |      Returns
 |      -------
 |      pp : PPoly
 |          Piecewise polynomial of order k2 = k + n representing
 |          the antiderivative of this polynomial.
 |      
 |      Notes
 |      -----
 |      The antiderivative returned by this function is continuous and
 |      continuously differentiable to order n-1, up to floating point
 |      rounding error.
 |  
 |  derivative(self, nu)
 |      Construct a new piecewise polynomial representing the derivative.
 |      
 |      Parameters
 |      ----------
 |      nu : ndim-tuple of int
 |          Order of derivatives to evaluate for each dimension.
 |          If negative, the antiderivative is returned.
 |      
 |      Returns
 |      -------
 |      pp : NdPPoly
 |          Piecewise polynomial of orders (k[0] - nu[0], ..., k[n] - nu[n])
 |          representing the derivative of this polynomial.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals in each dimension are
 |      considered half-open, ``[a, b)``, except for the last interval
 |      which is closed ``[a, b]``.
 |  
 |  integrate(self, ranges, extrapolate=None)
 |      Compute a definite integral over a piecewise polynomial.
 |      
 |      Parameters
 |      ----------
 |      ranges : ndim-tuple of 2-tuples float
 |          Sequence of lower and upper bounds for each dimension,
 |          ``[(a[0], b[0]), ..., (a[ndim-1], b[ndim-1])]``
 |      extrapolate : bool, optional
 |          Whether to extrapolate to out-of-bounds points based on first
 |          and last intervals, or to return NaNs.
 |      
 |      Returns
 |      -------
 |      ig : array_like
 |          Definite integral of the piecewise polynomial over
 |          [a[0], b[0]] x ... x [a[ndim-1], b[ndim-1]]
 |  
 |  integrate_1d(self, a, b, axis, extrapolate=None)
 |      Compute NdPPoly representation for one dimensional definite integral
 |      
 |      The result is a piecewise polynomial representing the integral:
 |      
 |      .. math::
 |      
 |         p(y, z, ...) = \int_a^b dx\, p(x, y, z, ...)
 |      
 |      where the dimension integrated over is specified with the
 |      `axis` parameter.
 |      
 |      Parameters
 |      ----------
 |      a, b : float
 |          Lower and upper bound for integration.
 |      axis : int
 |          Dimension over which to compute the 1D integrals
 |      extrapolate : bool, optional
 |          Whether to extrapolate to out-of-bounds points based on first
 |          and last intervals, or to return NaNs.
 |      
 |      Returns
 |      -------
 |      ig : NdPPoly or array-like
 |          Definite integral of the piecewise polynomial over [a, b].
 |          If the polynomial was 1-dimensional, an array is returned,
 |          otherwise, an NdPPoly object.
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  construct_fast(c, x, extrapolate=None) from builtins.type
 |      Construct the piecewise polynomial without making checks.
 |      
 |      Takes the same parameters as the constructor. Input arguments
 |      `c` and `x` must be arrays of the correct shape and type.  The
 |      `c` array can only be of dtypes float and complex, and `x`
 |      array must have dtype float.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, c, x, extrapolate=None)',)",scipy,1.1.0,scipy.interpolate.interpolate.NdPPoly,interpolate.interpolate,NdPPoly,"Python Library Documentation: class NdPPoly in module scipy.interpolate.interpolate

class NdPPoly(builtins.object)
 |  Piecewise tensor product polynomial
 |  
 |  The value at point `xp = (x', y', z', ...)` is evaluated by first
 |  computing the interval indices `i` such that::
 |  
 |      x[0][i[0]] <= x' < x[0][i[0]+1]
 |      x[1][i[1]] <= y' < x[1][i[1]+1]
 |      ...
 |  
 |  and then computing::
 |  
 |      S = sum(c[k0-m0-1,...,kn-mn-1,i[0],...,i[n]]
 |              * (xp[0] - x[0][i[0]])**m0
 |              * ...
 |              * (xp[n] - x[n][i[n]])**mn
 |              for m0 in range(k[0]+1)
 |              ...
 |              for mn in range(k[n]+1))
 |  
 |  where ``k[j]`` is the degree of the polynomial in dimension j. This
 |  representation is the piecewise multivariate power basis.
 |  
 |  Parameters
 |  ----------
 |  c : ndarray, shape (k0, ..., kn, m0, ..., mn, ...)
 |      Polynomial coefficients, with polynomial order `kj` and
 |      `mj+1` intervals for each dimension `j`.
 |  x : ndim-tuple of ndarrays, shapes (mj+1,)
 |      Polynomial breakpoints for each dimension. These must be
 |      sorted in increasing order.
 |  extrapolate : bool, optional
 |      Whether to extrapolate to out-of-bounds points based on first
 |      and last intervals, or to return NaNs. Default: True.
 |  
 |  Attributes
 |  ----------
 |  x : tuple of ndarrays
 |      Breakpoints.
 |  c : ndarray
 |      Coefficients of the polynomials.
 |  
 |  Methods
 |  -------
 |  __call__
 |  construct_fast
 |  
 |  See also
 |  --------
 |  PPoly : piecewise polynomials in 1D
 |  
 |  Notes
 |  -----
 |  High-order polynomials in the power basis can be numerically
 |  unstable.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, x, nu=None, extrapolate=None)
 |      Evaluate the piecewise polynomial or its derivative
 |      
 |      Parameters
 |      ----------
 |      x : array-like
 |          Points to evaluate the interpolant at.
 |      nu : tuple, optional
 |          Orders of derivatives to evaluate. Each must be non-negative.
 |      extrapolate : bool, optional
 |          Whether to extrapolate to out-of-bounds points based on first
 |          and last intervals, or to return NaNs.
 |      
 |      Returns
 |      -------
 |      y : array-like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  __init__(self, c, x, extrapolate=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  antiderivative(self, nu)
 |      Construct a new piecewise polynomial representing the antiderivative.
 |      
 |      Antiderivative is also the indefinite integral of the function,
 |      and derivative is its inverse operation.
 |      
 |      Parameters
 |      ----------
 |      nu : ndim-tuple of int
 |          Order of derivatives to evaluate for each dimension.
 |          If negative, the derivative is returned.
 |      
 |      Returns
 |      -------
 |      pp : PPoly
 |          Piecewise polynomial of order k2 = k + n representing
 |          the antiderivative of this polynomial.
 |      
 |      Notes
 |      -----
 |      The antiderivative returned by this function is continuous and
 |      continuously differentiable to order n-1, up to floating point
 |      rounding error.
 |  
 |  derivative(self, nu)
 |      Construct a new piecewise polynomial representing the derivative.
 |      
 |      Parameters
 |      ----------
 |      nu : ndim-tuple of int
 |          Order of derivatives to evaluate for each dimension.
 |          If negative, the antiderivative is returned.
 |      
 |      Returns
 |      -------
 |      pp : NdPPoly
 |          Piecewise polynomial of orders (k[0] - nu[0], ..., k[n] - nu[n])
 |          representing the derivative of this polynomial.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals in each dimension are
 |      considered half-open, ``[a, b)``, except for the last interval
 |      which is closed ``[a, b]``.
 |  
 |  integrate(self, ranges, extrapolate=None)
 |      Compute a definite integral over a piecewise polynomial.
 |      
 |      Parameters
 |      ----------
 |      ranges : ndim-tuple of 2-tuples float
 |          Sequence of lower and upper bounds for each dimension,
 |          ``[(a[0], b[0]), ..., (a[ndim-1], b[ndim-1])]``
 |      extrapolate : bool, optional
 |          Whether to extrapolate to out-of-bounds points based on first
 |          and last intervals, or to return NaNs.
 |      
 |      Returns
 |      -------
 |      ig : array_like
 |          Definite integral of the piecewise polynomial over
 |          [a[0], b[0]] x ... x [a[ndim-1], b[ndim-1]]
 |  
 |  integrate_1d(self, a, b, axis, extrapolate=None)
 |      Compute NdPPoly representation for one dimensional definite integral
 |      
 |      The result is a piecewise polynomial representing the integral:
 |      
 |      .. math::
 |      
 |         p(y, z, ...) = \int_a^b dx\, p(x, y, z, ...)
 |      
 |      where the dimension integrated over is specified with the
 |      `axis` parameter.
 |      
 |      Parameters
 |      ----------
 |      a, b : float
 |          Lower and upper bound for integration.
 |      axis : int
 |          Dimension over which to compute the 1D integrals
 |      extrapolate : bool, optional
 |          Whether to extrapolate to out-of-bounds points based on first
 |          and last intervals, or to return NaNs.
 |      
 |      Returns
 |      -------
 |      ig : NdPPoly or array-like
 |          Definite integral of the piecewise polynomial over [a, b].
 |          If the polynomial was 1-dimensional, an array is returned,
 |          otherwise, an NdPPoly object.
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  construct_fast(c, x, extrapolate=None) from builtins.type
 |      Construct the piecewise polynomial without making checks.
 |      
 |      Takes the same parameters as the constructor. Input arguments
 |      `c` and `x` must be arrays of the correct shape and type.  The
 |      `c` array can only be of dtypes float and complex, and `x`
 |      array must have dtype float.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'c', 'x', 'extrapolate')","(nan, nan, nan, None)","(nan, nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, c, x, extrapolate=None)',)"
scipy,1.1.0,scipy.interpolate.interpolate.NdPPoly.construct_fast,interpolate.interpolate.NdPPoly,construct_fast,"Python Library Documentation: method construct_fast in module scipy.interpolate.interpolate

construct_fast(c, x, extrapolate=None) method of builtins.type instance
    Construct the piecewise polynomial without making checks.
    
    Takes the same parameters as the constructor. Input arguments
    `c` and `x` must be arrays of the correct shape and type.  The
    `c` array can only be of dtypes float and complex, and `x`
    array must have dtype float.
",method,"('(c, x, extrapolate=None)',)",scipy,1.1.0,scipy.interpolate.interpolate.NdPPoly.construct_fast,interpolate.interpolate.NdPPoly,construct_fast,"Python Library Documentation: method construct_fast in module scipy.interpolate.interpolate

construct_fast(c, x, extrapolate=None) method of builtins.type instance
    Construct the piecewise polynomial without making checks.
    
    Takes the same parameters as the constructor. Input arguments
    `c` and `x` must be arrays of the correct shape and type.  The
    `c` array can only be of dtypes float and complex, and `x`
    array must have dtype float.
",method,"('cls', 'c', 'x', 'extrapolate')","(nan, nan, nan, None)","(nan, nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(c, x, extrapolate=None)',)"
scipy,1.1.0,scipy.interpolate.interpolate.PPoly,interpolate.interpolate,PPoly,"Python Library Documentation: class PPoly in module scipy.interpolate.interpolate

class PPoly(_PPolyBase)
 |  Piecewise polynomial in terms of coefficients and breakpoints
 |  
 |  The polynomial between ``x[i]`` and ``x[i + 1]`` is written in the
 |  local power basis::
 |  
 |      S = sum(c[m, i] * (xp - x[i])**(k-m) for m in range(k+1))
 |  
 |  where ``k`` is the degree of the polynomial.
 |  
 |  Parameters
 |  ----------
 |  c : ndarray, shape (k, m, ...)
 |      Polynomial coefficients, order `k` and `m` intervals
 |  x : ndarray, shape (m+1,)
 |      Polynomial breakpoints. Must be sorted in either increasing or
 |      decreasing order.
 |  extrapolate : bool or 'periodic', optional
 |      If bool, determines whether to extrapolate to out-of-bounds points
 |      based on first and last intervals, or to return NaNs. If 'periodic',
 |      periodic extrapolation is used. Default is True.
 |  axis : int, optional
 |      Interpolation axis. Default is zero.
 |  
 |  Attributes
 |  ----------
 |  x : ndarray
 |      Breakpoints.
 |  c : ndarray
 |      Coefficients of the polynomials. They are reshaped
 |      to a 3-dimensional array with the last dimension representing
 |      the trailing dimensions of the original coefficient array.
 |  axis : int
 |      Interpolation axis.
 |  
 |  Methods
 |  -------
 |  __call__
 |  derivative
 |  antiderivative
 |  integrate
 |  solve
 |  roots
 |  extend
 |  from_spline
 |  from_bernstein_basis
 |  construct_fast
 |  
 |  See also
 |  --------
 |  BPoly : piecewise polynomials in the Bernstein basis
 |  
 |  Notes
 |  -----
 |  High-order polynomials in the power basis can be numerically
 |  unstable.  Precision problems can start to appear for orders
 |  larger than 20-30.
 |  
 |  Method resolution order:
 |      PPoly
 |      _PPolyBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  antiderivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the antiderivative.
 |      
 |      Antiderivative is also the indefinite integral of the function,
 |      and derivative is its inverse operation.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of antiderivative to evaluate. Default is 1, i.e. compute
 |          the first integral. If negative, the derivative is returned.
 |      
 |      Returns
 |      -------
 |      pp : PPoly
 |          Piecewise polynomial of order k2 = k + n representing
 |          the antiderivative of this polynomial.
 |      
 |      Notes
 |      -----
 |      The antiderivative returned by this function is continuous and
 |      continuously differentiable to order n-1, up to floating point
 |      rounding error.
 |      
 |      If antiderivative is computed and ``self.extrapolate='periodic'``,
 |      it will be set to False for the returned instance. This is done because
 |      the antiderivative is no longer periodic and its correct evaluation
 |      outside of the initially given x interval is difficult.
 |  
 |  derivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the derivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of derivative to evaluate. Default is 1, i.e. compute the
 |          first derivative. If negative, the antiderivative is returned.
 |      
 |      Returns
 |      -------
 |      pp : PPoly
 |          Piecewise polynomial of order k2 = k - n representing the derivative
 |          of this polynomial.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  integrate(self, a, b, extrapolate=None)
 |      Compute a definite integral over a piecewise polynomial.
 |      
 |      Parameters
 |      ----------
 |      a : float
 |          Lower integration bound
 |      b : float
 |          Upper integration bound
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      ig : array_like
 |          Definite integral of the piecewise polynomial over [a, b]
 |  
 |  roots(self, discontinuity=True, extrapolate=None)
 |      Find real roots of the the piecewise polynomial.
 |      
 |      Parameters
 |      ----------
 |      discontinuity : bool, optional
 |          Whether to report sign changes across discontinuities at
 |          breakpoints as roots.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to return roots from the polynomial
 |          extrapolated based on first and last intervals, 'periodic' works
 |          the same as False. If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      roots : ndarray
 |          Roots of the polynomial(s).
 |      
 |          If the PPoly object describes multiple polynomials, the
 |          return value is an object array whose each element is an
 |          ndarray containing the roots.
 |      
 |      See Also
 |      --------
 |      PPoly.solve
 |  
 |  solve(self, y=0.0, discontinuity=True, extrapolate=None)
 |      Find real solutions of the the equation ``pp(x) == y``.
 |      
 |      Parameters
 |      ----------
 |      y : float, optional
 |          Right-hand side. Default is zero.
 |      discontinuity : bool, optional
 |          Whether to report sign changes across discontinuities at
 |          breakpoints as roots.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to return roots from the polynomial
 |          extrapolated based on first and last intervals, 'periodic' works
 |          the same as False. If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      roots : ndarray
 |          Roots of the polynomial(s).
 |      
 |          If the PPoly object describes multiple polynomials, the
 |          return value is an object array whose each element is an
 |          ndarray containing the roots.
 |      
 |      Notes
 |      -----
 |      This routine works only on real-valued polynomials.
 |      
 |      If the piecewise polynomial contains sections that are
 |      identically zero, the root list will contain the start point
 |      of the corresponding interval, followed by a ``nan`` value.
 |      
 |      If the polynomial is discontinuous across a breakpoint, and
 |      there is a sign change across the breakpoint, this is reported
 |      if the `discont` parameter is True.
 |      
 |      Examples
 |      --------
 |      
 |      Finding roots of ``[x**2 - 1, (x - 1)**2]`` defined on intervals
 |      ``[-2, 1], [1, 2]``:
 |      
 |      >>> from scipy.interpolate import PPoly
 |      >>> pp = PPoly(np.array([[1, -4, 3], [1, 0, 0]]).T, [-2, 1, 2])
 |      >>> pp.roots()
 |      array([-1.,  1.])
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_bernstein_basis(bp, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial in the power basis
 |      from a polynomial in Bernstein basis.
 |      
 |      Parameters
 |      ----------
 |      bp : BPoly
 |          A Bernstein basis polynomial, as created by BPoly
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |  
 |  from_spline(tck, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial from a spline
 |      
 |      Parameters
 |      ----------
 |      tck
 |          A spline, as returned by `splrep` or a BSpline object.
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _PPolyBase:
 |  
 |  __call__(self, x, nu=0, extrapolate=None)
 |      Evaluate the piecewise polynomial or its derivative.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      nu : int, optional
 |          Order of derivative to evaluate. Must be non-negative.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  __init__(self, c, x, extrapolate=None, axis=0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  extend(self, c, x, right=None)
 |      Add additional breakpoints and coefficients to the polynomial.
 |      
 |      Parameters
 |      ----------
 |      c : ndarray, size (k, m, ...)
 |          Additional coefficients for polynomials in intervals. Note that
 |          the first additional interval will be formed using one of the
 |          `self.x` end points.
 |      x : ndarray, size (m,)
 |          Additional breakpoints. Must be sorted in the same order as
 |          `self.x` and either to the right or to the left of the current
 |          breakpoints.
 |      right
 |          Deprecated argument. Has no effect.
 |      
 |          .. deprecated:: 0.19
 |  
 |  ----------------------------------------------------------------------
 |  Class methods inherited from _PPolyBase:
 |  
 |  construct_fast(c, x, extrapolate=None, axis=0) from builtins.type
 |      Construct the piecewise polynomial without making checks.
 |      
 |      Takes the same parameters as the constructor. Input arguments
 |      `c` and `x` must be arrays of the correct shape and type.  The
 |      `c` array can only be of dtypes float and complex, and `x`
 |      array must have dtype float.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _PPolyBase:
 |  
 |  axis
 |  
 |  c
 |  
 |  extrapolate
 |  
 |  x
",class,"('(self, c, x, extrapolate=None, axis=0)',)",scipy,1.1.0,scipy.interpolate.interpolate.PPoly,interpolate.interpolate,PPoly,"Python Library Documentation: class PPoly in module scipy.interpolate.interpolate

class PPoly(_PPolyBase)
 |  Piecewise polynomial in terms of coefficients and breakpoints
 |  
 |  The polynomial between ``x[i]`` and ``x[i + 1]`` is written in the
 |  local power basis::
 |  
 |      S = sum(c[m, i] * (xp - x[i])**(k-m) for m in range(k+1))
 |  
 |  where ``k`` is the degree of the polynomial.
 |  
 |  Parameters
 |  ----------
 |  c : ndarray, shape (k, m, ...)
 |      Polynomial coefficients, order `k` and `m` intervals
 |  x : ndarray, shape (m+1,)
 |      Polynomial breakpoints. Must be sorted in either increasing or
 |      decreasing order.
 |  extrapolate : bool or 'periodic', optional
 |      If bool, determines whether to extrapolate to out-of-bounds points
 |      based on first and last intervals, or to return NaNs. If 'periodic',
 |      periodic extrapolation is used. Default is True.
 |  axis : int, optional
 |      Interpolation axis. Default is zero.
 |  
 |  Attributes
 |  ----------
 |  x : ndarray
 |      Breakpoints.
 |  c : ndarray
 |      Coefficients of the polynomials. They are reshaped
 |      to a 3-dimensional array with the last dimension representing
 |      the trailing dimensions of the original coefficient array.
 |  axis : int
 |      Interpolation axis.
 |  
 |  Methods
 |  -------
 |  __call__
 |  derivative
 |  antiderivative
 |  integrate
 |  solve
 |  roots
 |  extend
 |  from_spline
 |  from_bernstein_basis
 |  construct_fast
 |  
 |  See also
 |  --------
 |  BPoly : piecewise polynomials in the Bernstein basis
 |  
 |  Notes
 |  -----
 |  High-order polynomials in the power basis can be numerically
 |  unstable.  Precision problems can start to appear for orders
 |  larger than 20-30.
 |  
 |  Method resolution order:
 |      PPoly
 |      _PPolyBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  antiderivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the antiderivative.
 |      
 |      Antiderivative is also the indefinite integral of the function,
 |      and derivative is its inverse operation.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of antiderivative to evaluate. Default is 1, i.e. compute
 |          the first integral. If negative, the derivative is returned.
 |      
 |      Returns
 |      -------
 |      pp : PPoly
 |          Piecewise polynomial of order k2 = k + n representing
 |          the antiderivative of this polynomial.
 |      
 |      Notes
 |      -----
 |      The antiderivative returned by this function is continuous and
 |      continuously differentiable to order n-1, up to floating point
 |      rounding error.
 |      
 |      If antiderivative is computed and ``self.extrapolate='periodic'``,
 |      it will be set to False for the returned instance. This is done because
 |      the antiderivative is no longer periodic and its correct evaluation
 |      outside of the initially given x interval is difficult.
 |  
 |  derivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the derivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of derivative to evaluate. Default is 1, i.e. compute the
 |          first derivative. If negative, the antiderivative is returned.
 |      
 |      Returns
 |      -------
 |      pp : PPoly
 |          Piecewise polynomial of order k2 = k - n representing the derivative
 |          of this polynomial.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  integrate(self, a, b, extrapolate=None)
 |      Compute a definite integral over a piecewise polynomial.
 |      
 |      Parameters
 |      ----------
 |      a : float
 |          Lower integration bound
 |      b : float
 |          Upper integration bound
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      ig : array_like
 |          Definite integral of the piecewise polynomial over [a, b]
 |  
 |  roots(self, discontinuity=True, extrapolate=None)
 |      Find real roots of the the piecewise polynomial.
 |      
 |      Parameters
 |      ----------
 |      discontinuity : bool, optional
 |          Whether to report sign changes across discontinuities at
 |          breakpoints as roots.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to return roots from the polynomial
 |          extrapolated based on first and last intervals, 'periodic' works
 |          the same as False. If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      roots : ndarray
 |          Roots of the polynomial(s).
 |      
 |          If the PPoly object describes multiple polynomials, the
 |          return value is an object array whose each element is an
 |          ndarray containing the roots.
 |      
 |      See Also
 |      --------
 |      PPoly.solve
 |  
 |  solve(self, y=0.0, discontinuity=True, extrapolate=None)
 |      Find real solutions of the the equation ``pp(x) == y``.
 |      
 |      Parameters
 |      ----------
 |      y : float, optional
 |          Right-hand side. Default is zero.
 |      discontinuity : bool, optional
 |          Whether to report sign changes across discontinuities at
 |          breakpoints as roots.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to return roots from the polynomial
 |          extrapolated based on first and last intervals, 'periodic' works
 |          the same as False. If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      roots : ndarray
 |          Roots of the polynomial(s).
 |      
 |          If the PPoly object describes multiple polynomials, the
 |          return value is an object array whose each element is an
 |          ndarray containing the roots.
 |      
 |      Notes
 |      -----
 |      This routine works only on real-valued polynomials.
 |      
 |      If the piecewise polynomial contains sections that are
 |      identically zero, the root list will contain the start point
 |      of the corresponding interval, followed by a ``nan`` value.
 |      
 |      If the polynomial is discontinuous across a breakpoint, and
 |      there is a sign change across the breakpoint, this is reported
 |      if the `discont` parameter is True.
 |      
 |      Examples
 |      --------
 |      
 |      Finding roots of ``[x**2 - 1, (x - 1)**2]`` defined on intervals
 |      ``[-2, 1], [1, 2]``:
 |      
 |      >>> from scipy.interpolate import PPoly
 |      >>> pp = PPoly(np.array([[1, -4, 3], [1, 0, 0]]).T, [-2, 1, 2])
 |      >>> pp.roots()
 |      array([-1.,  1.])
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_bernstein_basis(bp, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial in the power basis
 |      from a polynomial in Bernstein basis.
 |      
 |      Parameters
 |      ----------
 |      bp : BPoly
 |          A Bernstein basis polynomial, as created by BPoly
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |  
 |  from_spline(tck, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial from a spline
 |      
 |      Parameters
 |      ----------
 |      tck
 |          A spline, as returned by `splrep` or a BSpline object.
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _PPolyBase:
 |  
 |  __call__(self, x, nu=0, extrapolate=None)
 |      Evaluate the piecewise polynomial or its derivative.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      nu : int, optional
 |          Order of derivative to evaluate. Must be non-negative.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  __init__(self, c, x, extrapolate=None, axis=0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  extend(self, c, x, right=None)
 |      Add additional breakpoints and coefficients to the polynomial.
 |      
 |      Parameters
 |      ----------
 |      c : ndarray, size (k, m, ...)
 |          Additional coefficients for polynomials in intervals. Note that
 |          the first additional interval will be formed using one of the
 |          `self.x` end points.
 |      x : ndarray, size (m,)
 |          Additional breakpoints. Must be sorted in the same order as
 |          `self.x` and either to the right or to the left of the current
 |          breakpoints.
 |      right
 |          Deprecated argument. Has no effect.
 |      
 |          .. deprecated:: 0.19
 |  
 |  ----------------------------------------------------------------------
 |  Class methods inherited from _PPolyBase:
 |  
 |  construct_fast(c, x, extrapolate=None, axis=0) from builtins.type
 |      Construct the piecewise polynomial without making checks.
 |      
 |      Takes the same parameters as the constructor. Input arguments
 |      `c` and `x` must be arrays of the correct shape and type.  The
 |      `c` array can only be of dtypes float and complex, and `x`
 |      array must have dtype float.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _PPolyBase:
 |  
 |  axis
 |  
 |  c
 |  
 |  extrapolate
 |  
 |  x
",class,"('self', 'c', 'x', 'extrapolate', 'axis')","(nan, nan, nan, None, 0)","(nan, nan, nan, 'NoneType', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, c, x, extrapolate=None, axis=0)',)"
scipy,1.1.0,scipy.interpolate.interpolate.PPoly.construct_fast,interpolate.interpolate.PPoly,construct_fast,"Python Library Documentation: method construct_fast in module scipy.interpolate.interpolate

construct_fast(c, x, extrapolate=None, axis=0) method of builtins.type instance
    Construct the piecewise polynomial without making checks.
    
    Takes the same parameters as the constructor. Input arguments
    `c` and `x` must be arrays of the correct shape and type.  The
    `c` array can only be of dtypes float and complex, and `x`
    array must have dtype float.
",method,"('(c, x, extrapolate=None, axis=0)',)",scipy,1.1.0,scipy.interpolate.interpolate.PPoly.construct_fast,interpolate.interpolate.PPoly,construct_fast,"Python Library Documentation: method construct_fast in module scipy.interpolate.interpolate

construct_fast(c, x, extrapolate=None, axis=0) method of builtins.type instance
    Construct the piecewise polynomial without making checks.
    
    Takes the same parameters as the constructor. Input arguments
    `c` and `x` must be arrays of the correct shape and type.  The
    `c` array can only be of dtypes float and complex, and `x`
    array must have dtype float.
",method,"('cls', 'c', 'x', 'extrapolate', 'axis')","(nan, nan, nan, None, 0)","(nan, nan, nan, 'NoneType', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(c, x, extrapolate=None, axis=0)',)"
scipy,1.1.0,scipy.interpolate.interpolate.PPoly.from_bernstein_basis,interpolate.interpolate.PPoly,from_bernstein_basis,"Python Library Documentation: method from_bernstein_basis in module scipy.interpolate.interpolate

from_bernstein_basis(bp, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial in the power basis
    from a polynomial in Bernstein basis.
    
    Parameters
    ----------
    bp : BPoly
        A Bernstein basis polynomial, as created by BPoly
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
",method,"('(bp, extrapolate=None)',)",scipy,1.1.0,scipy.interpolate.interpolate.PPoly.from_bernstein_basis,interpolate.interpolate.PPoly,from_bernstein_basis,"Python Library Documentation: method from_bernstein_basis in module scipy.interpolate.interpolate

from_bernstein_basis(bp, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial in the power basis
    from a polynomial in Bernstein basis.
    
    Parameters
    ----------
    bp : BPoly
        A Bernstein basis polynomial, as created by BPoly
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
",method,"('cls', 'bp', 'extrapolate')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(bp, extrapolate=None)',)"
scipy,1.1.0,scipy.interpolate.interpolate.PPoly.from_spline,interpolate.interpolate.PPoly,from_spline,"Python Library Documentation: method from_spline in module scipy.interpolate.interpolate

from_spline(tck, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial from a spline
    
    Parameters
    ----------
    tck
        A spline, as returned by `splrep` or a BSpline object.
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
",method,"('(tck, extrapolate=None)',)",scipy,1.1.0,scipy.interpolate.interpolate.PPoly.from_spline,interpolate.interpolate.PPoly,from_spline,"Python Library Documentation: method from_spline in module scipy.interpolate.interpolate

from_spline(tck, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial from a spline
    
    Parameters
    ----------
    tck
        A spline, as returned by `splrep` or a BSpline object.
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
",method,"('cls', 'tck', 'extrapolate')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(tck, extrapolate=None)',)"
scipy,1.1.0,scipy.interpolate.interpolate.RectBivariateSpline,interpolate.interpolate,RectBivariateSpline,"Python Library Documentation: class RectBivariateSpline in module scipy.interpolate.fitpack2

class RectBivariateSpline(BivariateSpline)
 |  Bivariate spline approximation over a rectangular mesh.
 |  
 |  Can be used for both smoothing and interpolating data.
 |  
 |  Parameters
 |  ----------
 |  x,y : array_like
 |      1-D arrays of coordinates in strictly ascending order.
 |  z : array_like
 |      2-D array of data with shape (x.size,y.size).
 |  bbox : array_like, optional
 |      Sequence of length 4 specifying the boundary of the rectangular
 |      approximation domain.  By default,
 |      ``bbox=[min(x,tx),max(x,tx), min(y,ty),max(y,ty)]``.
 |  kx, ky : ints, optional
 |      Degrees of the bivariate spline. Default is 3.
 |  s : float, optional
 |      Positive smoothing factor defined for estimation condition:
 |      ``sum((w[i]*(z[i]-s(x[i], y[i])))**2, axis=0) <= s``
 |      Default is ``s=0``, which is for interpolation.
 |  
 |  See Also
 |  --------
 |  SmoothBivariateSpline : a smoothing bivariate spline for scattered data
 |  bisplrep : an older wrapping of FITPACK
 |  bisplev : an older wrapping of FITPACK
 |  UnivariateSpline : a similar class for univariate spline interpolation
 |  
 |  Method resolution order:
 |      RectBivariateSpline
 |      BivariateSpline
 |      _BivariateSplineBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, x, y, z, bbox=[None, None, None, None], kx=3, ky=3, s=0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from BivariateSpline:
 |  
 |  ev(self, xi, yi, dx=0, dy=0)
 |      Evaluate the spline at points
 |      
 |      Returns the interpolated value at ``(xi[i], yi[i]),
 |      i=0,...,len(xi)-1``.
 |      
 |      Parameters
 |      ----------
 |      xi, yi : array_like
 |          Input coordinates. Standard Numpy broadcasting is obeyed.
 |      dx : int, optional
 |          Order of x-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dy : int, optional
 |          Order of y-derivative
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  integral(self, xa, xb, ya, yb)
 |      Evaluate the integral of the spline over area [xa,xb] x [ya,yb].
 |      
 |      Parameters
 |      ----------
 |      xa, xb : float
 |          The end-points of the x integration interval.
 |      ya, yb : float
 |          The end-points of the y integration interval.
 |      
 |      Returns
 |      -------
 |      integ : float
 |          The value of the resulting integral.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BivariateSplineBase:
 |  
 |  __call__(self, x, y, dx=0, dy=0, grid=True)
 |      Evaluate the spline or its derivatives at given positions.
 |      
 |      Parameters
 |      ----------
 |      x, y : array_like
 |          Input coordinates.
 |      
 |          If `grid` is False, evaluate the spline at points ``(x[i],
 |          y[i]), i=0, ..., len(x)-1``.  Standard Numpy broadcasting
 |          is obeyed.
 |      
 |          If `grid` is True: evaluate spline at the grid points
 |          defined by the coordinate arrays x, y. The arrays must be
 |          sorted to increasing order.
 |          
 |          Note that the axis ordering is inverted relative to
 |          the output of meshgrid.
 |      dx : int
 |          Order of x-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dy : int
 |          Order of y-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      grid : bool
 |          Whether to evaluate the results on a grid spanned by the
 |          input arrays, or at points specified by the input arrays.
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  get_coeffs(self)
 |      Return spline coefficients.
 |  
 |  get_knots(self)
 |      Return a tuple (tx,ty) where tx,ty contain knots positions
 |      of the spline with respect to x-, y-variable, respectively.
 |      The position of interior and additional knots are given as
 |      t[k+1:-k-1] and t[:k+1]=b, t[-k-1:]=e, respectively.
 |  
 |  get_residual(self)
 |      Return weighted sum of squared residuals of the spline
 |      approximation: sum ((w[i]*(z[i]-s(x[i],y[i])))**2,axis=0)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BivariateSplineBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, x, y, z, bbox=[None, None, None, None], kx=3, ky=3, s=0)',)",scipy,1.1.0,scipy.interpolate.interpolate.RectBivariateSpline,interpolate.interpolate,RectBivariateSpline,"Python Library Documentation: class RectBivariateSpline in module scipy.interpolate.fitpack2

class RectBivariateSpline(BivariateSpline)
 |  Bivariate spline approximation over a rectangular mesh.
 |  
 |  Can be used for both smoothing and interpolating data.
 |  
 |  Parameters
 |  ----------
 |  x,y : array_like
 |      1-D arrays of coordinates in strictly ascending order.
 |  z : array_like
 |      2-D array of data with shape (x.size,y.size).
 |  bbox : array_like, optional
 |      Sequence of length 4 specifying the boundary of the rectangular
 |      approximation domain.  By default,
 |      ``bbox=[min(x,tx),max(x,tx), min(y,ty),max(y,ty)]``.
 |  kx, ky : ints, optional
 |      Degrees of the bivariate spline. Default is 3.
 |  s : float, optional
 |      Positive smoothing factor defined for estimation condition:
 |      ``sum((w[i]*(z[i]-s(x[i], y[i])))**2, axis=0) <= s``
 |      Default is ``s=0``, which is for interpolation.
 |  
 |  See Also
 |  --------
 |  SmoothBivariateSpline : a smoothing bivariate spline for scattered data
 |  bisplrep : an older wrapping of FITPACK
 |  bisplev : an older wrapping of FITPACK
 |  UnivariateSpline : a similar class for univariate spline interpolation
 |  
 |  Method resolution order:
 |      RectBivariateSpline
 |      BivariateSpline
 |      _BivariateSplineBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, x, y, z, bbox=[None, None, None, None], kx=3, ky=3, s=0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from BivariateSpline:
 |  
 |  ev(self, xi, yi, dx=0, dy=0)
 |      Evaluate the spline at points
 |      
 |      Returns the interpolated value at ``(xi[i], yi[i]),
 |      i=0,...,len(xi)-1``.
 |      
 |      Parameters
 |      ----------
 |      xi, yi : array_like
 |          Input coordinates. Standard Numpy broadcasting is obeyed.
 |      dx : int, optional
 |          Order of x-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dy : int, optional
 |          Order of y-derivative
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  integral(self, xa, xb, ya, yb)
 |      Evaluate the integral of the spline over area [xa,xb] x [ya,yb].
 |      
 |      Parameters
 |      ----------
 |      xa, xb : float
 |          The end-points of the x integration interval.
 |      ya, yb : float
 |          The end-points of the y integration interval.
 |      
 |      Returns
 |      -------
 |      integ : float
 |          The value of the resulting integral.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BivariateSplineBase:
 |  
 |  __call__(self, x, y, dx=0, dy=0, grid=True)
 |      Evaluate the spline or its derivatives at given positions.
 |      
 |      Parameters
 |      ----------
 |      x, y : array_like
 |          Input coordinates.
 |      
 |          If `grid` is False, evaluate the spline at points ``(x[i],
 |          y[i]), i=0, ..., len(x)-1``.  Standard Numpy broadcasting
 |          is obeyed.
 |      
 |          If `grid` is True: evaluate spline at the grid points
 |          defined by the coordinate arrays x, y. The arrays must be
 |          sorted to increasing order.
 |          
 |          Note that the axis ordering is inverted relative to
 |          the output of meshgrid.
 |      dx : int
 |          Order of x-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      dy : int
 |          Order of y-derivative
 |      
 |          .. versionadded:: 0.14.0
 |      grid : bool
 |          Whether to evaluate the results on a grid spanned by the
 |          input arrays, or at points specified by the input arrays.
 |      
 |          .. versionadded:: 0.14.0
 |  
 |  get_coeffs(self)
 |      Return spline coefficients.
 |  
 |  get_knots(self)
 |      Return a tuple (tx,ty) where tx,ty contain knots positions
 |      of the spline with respect to x-, y-variable, respectively.
 |      The position of interior and additional knots are given as
 |      t[k+1:-k-1] and t[:k+1]=b, t[-k-1:]=e, respectively.
 |  
 |  get_residual(self)
 |      Return weighted sum of squared residuals of the spline
 |      approximation: sum ((w[i]*(z[i]-s(x[i],y[i])))**2,axis=0)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BivariateSplineBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'x', 'y', 'z', 'bbox', 'kx', 'ky', 's')","(nan, nan, nan, nan, [None, None, None, None], 3, 3, 0)","(nan, nan, nan, nan, 'list', 'int', 'int', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, x, y, z, bbox=[None, None, None, None], kx=3, ky=3, s=0)',)"
scipy,1.1.0,scipy.interpolate.interpolate.RectBivariateSpline._from_tck,interpolate.interpolate.RectBivariateSpline,_from_tck,"Python Library Documentation: method _from_tck in module scipy.interpolate.fitpack2

_from_tck(tck) method of builtins.type instance
    Construct a spline object from given tck and degree
",method,"('(tck)',)",scipy,1.1.0,scipy.interpolate.interpolate.RectBivariateSpline._from_tck,interpolate.interpolate.RectBivariateSpline,_from_tck,"Python Library Documentation: method _from_tck in module scipy.interpolate.fitpack2

_from_tck(tck) method of builtins.type instance
    Construct a spline object from given tck and degree
",method,"('cls', 'tck')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(tck)',)"
scipy,1.1.0,scipy.interpolate.interpolate.RegularGridInterpolator,interpolate.interpolate,RegularGridInterpolator,"Python Library Documentation: class RegularGridInterpolator in module scipy.interpolate.interpolate

class RegularGridInterpolator(builtins.object)
 |  Interpolation on a regular grid in arbitrary dimensions
 |  
 |  The data must be defined on a regular grid; the grid spacing however may be
 |  uneven.  Linear and nearest-neighbour interpolation are supported. After
 |  setting up the interpolator object, the interpolation method (*linear* or
 |  *nearest*) may be chosen at each evaluation.
 |  
 |  Parameters
 |  ----------
 |  points : tuple of ndarray of float, with shapes (m1, ), ..., (mn, )
 |      The points defining the regular grid in n dimensions.
 |  
 |  values : array_like, shape (m1, ..., mn, ...)
 |      The data on the regular grid in n dimensions.
 |  
 |  method : str, optional
 |      The method of interpolation to perform. Supported are ""linear"" and
 |      ""nearest"". This parameter will become the default for the object's
 |      ``__call__`` method. Default is ""linear"".
 |  
 |  bounds_error : bool, optional
 |      If True, when interpolated values are requested outside of the
 |      domain of the input data, a ValueError is raised.
 |      If False, then `fill_value` is used.
 |  
 |  fill_value : number, optional
 |      If provided, the value to use for points outside of the
 |      interpolation domain. If None, values outside
 |      the domain are extrapolated.
 |  
 |  Methods
 |  -------
 |  __call__
 |  
 |  Notes
 |  -----
 |  Contrary to LinearNDInterpolator and NearestNDInterpolator, this class
 |  avoids expensive triangulation of the input data by taking advantage of the
 |  regular grid structure.
 |  
 |  If any of `points` have a dimension of size 1, linear interpolation will
 |  return an array of `nan` values. Nearest-neighbor interpolation will work
 |  as usual in this case.
 |  
 |  .. versionadded:: 0.14
 |  
 |  Examples
 |  --------
 |  Evaluate a simple example function on the points of a 3D grid:
 |  
 |  >>> from scipy.interpolate import RegularGridInterpolator
 |  >>> def f(x, y, z):
 |  ...     return 2 * x**3 + 3 * y**2 - z
 |  >>> x = np.linspace(1, 4, 11)
 |  >>> y = np.linspace(4, 7, 22)
 |  >>> z = np.linspace(7, 9, 33)
 |  >>> data = f(*np.meshgrid(x, y, z, indexing='ij', sparse=True))
 |  
 |  ``data`` is now a 3D array with ``data[i,j,k] = f(x[i], y[j], z[k])``.
 |  Next, define an interpolating function from this data:
 |  
 |  >>> my_interpolating_function = RegularGridInterpolator((x, y, z), data)
 |  
 |  Evaluate the interpolating function at the two points
 |  ``(x,y,z) = (2.1, 6.2, 8.3)`` and ``(3.3, 5.2, 7.1)``:
 |  
 |  >>> pts = np.array([[2.1, 6.2, 8.3], [3.3, 5.2, 7.1]])
 |  >>> my_interpolating_function(pts)
 |  array([ 125.80469388,  146.30069388])
 |  
 |  which is indeed a close approximation to
 |  ``[f(2.1, 6.2, 8.3), f(3.3, 5.2, 7.1)]``.
 |  
 |  See also
 |  --------
 |  NearestNDInterpolator : Nearest neighbour interpolation on unstructured
 |                          data in N dimensions
 |  
 |  LinearNDInterpolator : Piecewise linear interpolant on unstructured data
 |                         in N dimensions
 |  
 |  References
 |  ----------
 |  .. [1] Python package *regulargrid* by Johannes Buchner, see
 |         https://pypi.python.org/pypi/regulargrid/
 |  .. [2] Trilinear interpolation. (2013, January 17). In Wikipedia, The Free
 |         Encyclopedia. Retrieved 27 Feb 2013 01:28.
 |         http://en.wikipedia.org/w/index.php?title=Trilinear_interpolation&oldid=533448871
 |  .. [3] Weiser, Alan, and Sergio E. Zarantonello. ""A note on piecewise linear
 |         and multilinear table interpolation in many dimensions."" MATH.
 |         COMPUT. 50.181 (1988): 189-196.
 |         http://www.ams.org/journals/mcom/1988-50-181/S0025-5718-1988-0917826-0/S0025-5718-1988-0917826-0.pdf
 |  
 |  Methods defined here:
 |  
 |  __call__(self, xi, method=None)
 |      Interpolation at coordinates
 |      
 |      Parameters
 |      ----------
 |      xi : ndarray of shape (..., ndim)
 |          The coordinates to sample the gridded data at
 |      
 |      method : str
 |          The method of interpolation to perform. Supported are ""linear"" and
 |          ""nearest"".
 |  
 |  __init__(self, points, values, method='linear', bounds_error=True, fill_value=nan)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"(""(self, points, values, method='linear', bounds_error=True, fill_value=nan)"",)",scipy,1.1.0,scipy.interpolate.interpolate.RegularGridInterpolator,interpolate.interpolate,RegularGridInterpolator,"Python Library Documentation: class RegularGridInterpolator in module scipy.interpolate.interpolate

class RegularGridInterpolator(builtins.object)
 |  Interpolation on a regular grid in arbitrary dimensions
 |  
 |  The data must be defined on a regular grid; the grid spacing however may be
 |  uneven.  Linear and nearest-neighbour interpolation are supported. After
 |  setting up the interpolator object, the interpolation method (*linear* or
 |  *nearest*) may be chosen at each evaluation.
 |  
 |  Parameters
 |  ----------
 |  points : tuple of ndarray of float, with shapes (m1, ), ..., (mn, )
 |      The points defining the regular grid in n dimensions.
 |  
 |  values : array_like, shape (m1, ..., mn, ...)
 |      The data on the regular grid in n dimensions.
 |  
 |  method : str, optional
 |      The method of interpolation to perform. Supported are ""linear"" and
 |      ""nearest"". This parameter will become the default for the object's
 |      ``__call__`` method. Default is ""linear"".
 |  
 |  bounds_error : bool, optional
 |      If True, when interpolated values are requested outside of the
 |      domain of the input data, a ValueError is raised.
 |      If False, then `fill_value` is used.
 |  
 |  fill_value : number, optional
 |      If provided, the value to use for points outside of the
 |      interpolation domain. If None, values outside
 |      the domain are extrapolated.
 |  
 |  Methods
 |  -------
 |  __call__
 |  
 |  Notes
 |  -----
 |  Contrary to LinearNDInterpolator and NearestNDInterpolator, this class
 |  avoids expensive triangulation of the input data by taking advantage of the
 |  regular grid structure.
 |  
 |  If any of `points` have a dimension of size 1, linear interpolation will
 |  return an array of `nan` values. Nearest-neighbor interpolation will work
 |  as usual in this case.
 |  
 |  .. versionadded:: 0.14
 |  
 |  Examples
 |  --------
 |  Evaluate a simple example function on the points of a 3D grid:
 |  
 |  >>> from scipy.interpolate import RegularGridInterpolator
 |  >>> def f(x, y, z):
 |  ...     return 2 * x**3 + 3 * y**2 - z
 |  >>> x = np.linspace(1, 4, 11)
 |  >>> y = np.linspace(4, 7, 22)
 |  >>> z = np.linspace(7, 9, 33)
 |  >>> data = f(*np.meshgrid(x, y, z, indexing='ij', sparse=True))
 |  
 |  ``data`` is now a 3D array with ``data[i,j,k] = f(x[i], y[j], z[k])``.
 |  Next, define an interpolating function from this data:
 |  
 |  >>> my_interpolating_function = RegularGridInterpolator((x, y, z), data)
 |  
 |  Evaluate the interpolating function at the two points
 |  ``(x,y,z) = (2.1, 6.2, 8.3)`` and ``(3.3, 5.2, 7.1)``:
 |  
 |  >>> pts = np.array([[2.1, 6.2, 8.3], [3.3, 5.2, 7.1]])
 |  >>> my_interpolating_function(pts)
 |  array([ 125.80469388,  146.30069388])
 |  
 |  which is indeed a close approximation to
 |  ``[f(2.1, 6.2, 8.3), f(3.3, 5.2, 7.1)]``.
 |  
 |  See also
 |  --------
 |  NearestNDInterpolator : Nearest neighbour interpolation on unstructured
 |                          data in N dimensions
 |  
 |  LinearNDInterpolator : Piecewise linear interpolant on unstructured data
 |                         in N dimensions
 |  
 |  References
 |  ----------
 |  .. [1] Python package *regulargrid* by Johannes Buchner, see
 |         https://pypi.python.org/pypi/regulargrid/
 |  .. [2] Trilinear interpolation. (2013, January 17). In Wikipedia, The Free
 |         Encyclopedia. Retrieved 27 Feb 2013 01:28.
 |         http://en.wikipedia.org/w/index.php?title=Trilinear_interpolation&oldid=533448871
 |  .. [3] Weiser, Alan, and Sergio E. Zarantonello. ""A note on piecewise linear
 |         and multilinear table interpolation in many dimensions."" MATH.
 |         COMPUT. 50.181 (1988): 189-196.
 |         http://www.ams.org/journals/mcom/1988-50-181/S0025-5718-1988-0917826-0/S0025-5718-1988-0917826-0.pdf
 |  
 |  Methods defined here:
 |  
 |  __call__(self, xi, method=None)
 |      Interpolation at coordinates
 |      
 |      Parameters
 |      ----------
 |      xi : ndarray of shape (..., ndim)
 |          The coordinates to sample the gridded data at
 |      
 |      method : str
 |          The method of interpolation to perform. Supported are ""linear"" and
 |          ""nearest"".
 |  
 |  __init__(self, points, values, method='linear', bounds_error=True, fill_value=nan)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'points', 'values', 'method', 'bounds_error', 'fill_value')","(nan, nan, nan, 'linear', True, nan)","(nan, nan, nan, 'str', 'bool', nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(self, points, values, method='linear', bounds_error=True, fill_value=nan)"",)"
scipy,1.1.0,scipy.interpolate.interpolate._Interpolator1D,interpolate.interpolate,_Interpolator1D,"Python Library Documentation: class _Interpolator1D in module scipy.interpolate.polyint

class _Interpolator1D(builtins.object)
 |  Common features in univariate interpolation
 |  
 |  Deal with input data type and interpolation axis rolling.  The
 |  actual interpolator can assume the y-data is of shape (n, r) where
 |  `n` is the number of x-points, and `r` the number of variables,
 |  and use self.dtype as the y-data type.
 |  
 |  Attributes
 |  ----------
 |  _y_axis
 |      Axis along which the interpolation goes in the original array
 |  _y_extra_shape
 |      Additional trailing shape of the input arrays, excluding
 |      the interpolation axis.
 |  dtype
 |      Dtype of the y-data arrays. Can be set via set_dtype, which
 |      forces it to be float or complex.
 |  
 |  Methods
 |  -------
 |  __call__
 |  _prepare_x
 |  _finish_y
 |  _reshape_yi
 |  _set_yi
 |  _set_dtype
 |  _evaluate
 |  
 |  Methods defined here:
 |  
 |  __call__(self, x)
 |      Evaluate the interpolant
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |  
 |  __init__(self, xi=None, yi=None, axis=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  dtype
",class,"('(self, xi=None, yi=None, axis=None)',)",scipy,1.1.0,scipy.interpolate.interpolate._Interpolator1D,interpolate.interpolate,_Interpolator1D,"Python Library Documentation: class _Interpolator1D in module scipy.interpolate.polyint

class _Interpolator1D(builtins.object)
 |  Common features in univariate interpolation
 |  
 |  Deal with input data type and interpolation axis rolling.  The
 |  actual interpolator can assume the y-data is of shape (n, r) where
 |  `n` is the number of x-points, and `r` the number of variables,
 |  and use self.dtype as the y-data type.
 |  
 |  Attributes
 |  ----------
 |  _y_axis
 |      Axis along which the interpolation goes in the original array
 |  _y_extra_shape
 |      Additional trailing shape of the input arrays, excluding
 |      the interpolation axis.
 |  dtype
 |      Dtype of the y-data arrays. Can be set via set_dtype, which
 |      forces it to be float or complex.
 |  
 |  Methods
 |  -------
 |  __call__
 |  _prepare_x
 |  _finish_y
 |  _reshape_yi
 |  _set_yi
 |  _set_dtype
 |  _evaluate
 |  
 |  Methods defined here:
 |  
 |  __call__(self, x)
 |      Evaluate the interpolant
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |  
 |  __init__(self, xi=None, yi=None, axis=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  dtype
",class,"('self', 'xi', 'yi', 'axis')","(nan, None, None, None)","(nan, 'NoneType', 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, xi=None, yi=None, axis=None)',)"
scipy,1.1.0,scipy.interpolate.interpolate._PPolyBase,interpolate.interpolate,_PPolyBase,"Python Library Documentation: class _PPolyBase in module scipy.interpolate.interpolate

class _PPolyBase(builtins.object)
 |  Base class for piecewise polynomials.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, x, nu=0, extrapolate=None)
 |      Evaluate the piecewise polynomial or its derivative.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      nu : int, optional
 |          Order of derivative to evaluate. Must be non-negative.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  __init__(self, c, x, extrapolate=None, axis=0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  extend(self, c, x, right=None)
 |      Add additional breakpoints and coefficients to the polynomial.
 |      
 |      Parameters
 |      ----------
 |      c : ndarray, size (k, m, ...)
 |          Additional coefficients for polynomials in intervals. Note that
 |          the first additional interval will be formed using one of the
 |          `self.x` end points.
 |      x : ndarray, size (m,)
 |          Additional breakpoints. Must be sorted in the same order as
 |          `self.x` and either to the right or to the left of the current
 |          breakpoints.
 |      right
 |          Deprecated argument. Has no effect.
 |      
 |          .. deprecated:: 0.19
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  construct_fast(c, x, extrapolate=None, axis=0) from builtins.type
 |      Construct the piecewise polynomial without making checks.
 |      
 |      Takes the same parameters as the constructor. Input arguments
 |      `c` and `x` must be arrays of the correct shape and type.  The
 |      `c` array can only be of dtypes float and complex, and `x`
 |      array must have dtype float.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  axis
 |  
 |  c
 |  
 |  extrapolate
 |  
 |  x
",class,"('(self, c, x, extrapolate=None, axis=0)',)",scipy,1.1.0,scipy.interpolate.interpolate._PPolyBase,interpolate.interpolate,_PPolyBase,"Python Library Documentation: class _PPolyBase in module scipy.interpolate.interpolate

class _PPolyBase(builtins.object)
 |  Base class for piecewise polynomials.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, x, nu=0, extrapolate=None)
 |      Evaluate the piecewise polynomial or its derivative.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      nu : int, optional
 |          Order of derivative to evaluate. Must be non-negative.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  __init__(self, c, x, extrapolate=None, axis=0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  extend(self, c, x, right=None)
 |      Add additional breakpoints and coefficients to the polynomial.
 |      
 |      Parameters
 |      ----------
 |      c : ndarray, size (k, m, ...)
 |          Additional coefficients for polynomials in intervals. Note that
 |          the first additional interval will be formed using one of the
 |          `self.x` end points.
 |      x : ndarray, size (m,)
 |          Additional breakpoints. Must be sorted in the same order as
 |          `self.x` and either to the right or to the left of the current
 |          breakpoints.
 |      right
 |          Deprecated argument. Has no effect.
 |      
 |          .. deprecated:: 0.19
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  construct_fast(c, x, extrapolate=None, axis=0) from builtins.type
 |      Construct the piecewise polynomial without making checks.
 |      
 |      Takes the same parameters as the constructor. Input arguments
 |      `c` and `x` must be arrays of the correct shape and type.  The
 |      `c` array can only be of dtypes float and complex, and `x`
 |      array must have dtype float.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  axis
 |  
 |  c
 |  
 |  extrapolate
 |  
 |  x
",class,"('self', 'c', 'x', 'extrapolate', 'axis')","(nan, nan, nan, None, 0)","(nan, nan, nan, 'NoneType', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, c, x, extrapolate=None, axis=0)',)"
scipy,1.1.0,scipy.interpolate.interpolate._PPolyBase.construct_fast,interpolate.interpolate._PPolyBase,construct_fast,"Python Library Documentation: method construct_fast in module scipy.interpolate.interpolate

construct_fast(c, x, extrapolate=None, axis=0) method of builtins.type instance
    Construct the piecewise polynomial without making checks.
    
    Takes the same parameters as the constructor. Input arguments
    `c` and `x` must be arrays of the correct shape and type.  The
    `c` array can only be of dtypes float and complex, and `x`
    array must have dtype float.
",method,"('(c, x, extrapolate=None, axis=0)',)",scipy,1.1.0,scipy.interpolate.interpolate._PPolyBase.construct_fast,interpolate.interpolate._PPolyBase,construct_fast,"Python Library Documentation: method construct_fast in module scipy.interpolate.interpolate

construct_fast(c, x, extrapolate=None, axis=0) method of builtins.type instance
    Construct the piecewise polynomial without making checks.
    
    Takes the same parameters as the constructor. Input arguments
    `c` and `x` must be arrays of the correct shape and type.  The
    `c` array can only be of dtypes float and complex, and `x`
    array must have dtype float.
",method,"('cls', 'c', 'x', 'extrapolate', 'axis')","(nan, nan, nan, None, 0)","(nan, nan, nan, 'NoneType', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(c, x, extrapolate=None, axis=0)',)"
scipy,1.1.0,scipy.interpolate.interpolate._check_broadcast_up_to,interpolate.interpolate,_check_broadcast_up_to,"Python Library Documentation: function _check_broadcast_up_to in module scipy.interpolate.interpolate

_check_broadcast_up_to(arr_from, shape_to, name)
    Helper to check that arr_from broadcasts up to shape_to
",function,"('(arr_from, shape_to, name)',)",scipy,1.1.0,scipy.interpolate.interpolate._check_broadcast_up_to,interpolate.interpolate,_check_broadcast_up_to,"Python Library Documentation: function _check_broadcast_up_to in module scipy.interpolate.interpolate

_check_broadcast_up_to(arr_from, shape_to, name)
    Helper to check that arr_from broadcasts up to shape_to
",function,"('arr_from', 'shape_to', 'name')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(arr_from, shape_to, name)',)"
scipy,1.1.0,scipy.interpolate.interpolate._do_extrapolate,interpolate.interpolate,_do_extrapolate,"Python Library Documentation: function _do_extrapolate in module scipy.interpolate.interpolate

_do_extrapolate(fill_value)
    Helper to check if fill_value == ""extrapolate"" without warnings
",function,"('(fill_value)',)",scipy,1.1.0,scipy.interpolate.interpolate._do_extrapolate,interpolate.interpolate,_do_extrapolate,"Python Library Documentation: function _do_extrapolate in module scipy.interpolate.interpolate

_do_extrapolate(fill_value)
    Helper to check if fill_value == ""extrapolate"" without warnings
",function,"('fill_value',)","(nan,)","(nan,)","('arg_info',)","('(fill_value)',)"
scipy,1.1.0,scipy.interpolate.interpolate._dot0,interpolate.interpolate,_dot0,"Python Library Documentation: function _dot0 in module scipy.interpolate.interpolate

_dot0(a, b)
    Similar to numpy.dot, but sum over last axis of a and 1st axis of b
",function,"('(a, b)',)",scipy,1.1.0,scipy.interpolate.interpolate._dot0,interpolate.interpolate,_dot0,"Python Library Documentation: function _dot0 in module scipy.interpolate.interpolate

_dot0(a, b)
    Similar to numpy.dot, but sum over last axis of a and 1st axis of b
",function,"('a', 'b')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(a, b)',)"
scipy,1.1.0,scipy.interpolate.interpolate._find_smoothest,interpolate.interpolate,_find_smoothest,"Python Library Documentation: function _find_smoothest in module scipy.interpolate.interpolate

_find_smoothest(xk, yk, order, conds=None, B=None)
",function,"('(xk, yk, order, conds=None, B=None)',)",scipy,1.1.0,scipy.interpolate.interpolate._find_smoothest,interpolate.interpolate,_find_smoothest,"Python Library Documentation: function _find_smoothest in module scipy.interpolate.interpolate

_find_smoothest(xk, yk, order, conds=None, B=None)
",function,"('xk', 'yk', 'order', 'conds', 'B')","(nan, nan, nan, None, None)","(nan, nan, nan, 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(xk, yk, order, conds=None, B=None)',)"
scipy,1.1.0,scipy.interpolate.interpolate._find_user,interpolate.interpolate,_find_user,"Python Library Documentation: function _find_user in module scipy.interpolate.interpolate

_find_user(xk, yk, order, conds, B)
",function,"('(xk, yk, order, conds, B)',)",scipy,1.1.0,scipy.interpolate.interpolate._find_user,interpolate.interpolate,_find_user,"Python Library Documentation: function _find_user in module scipy.interpolate.interpolate

_find_user(xk, yk, order, conds, B)
",function,"('xk', 'yk', 'order', 'conds', 'B')","(nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(xk, yk, order, conds, B)',)"
scipy,1.1.0,scipy.interpolate.interpolate._ppform,interpolate.interpolate,_ppform,"Python Library Documentation: class _ppform in module scipy.interpolate.interpolate

class _ppform(PPoly)
 |  Deprecated piecewise polynomial class.
 |  
 |  New code should use the `PPoly` class instead.
 |  
 |  Method resolution order:
 |      _ppform
 |      PPoly
 |      _PPolyBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __call__(self, x)
 |      Evaluate the piecewise polynomial or its derivative.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      nu : int, optional
 |          Order of derivative to evaluate. Must be non-negative.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  __init__(self, coeffs, breaks, fill=0.0, sort=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  fromspline(xk, cvals, order, fill=0.0) from builtins.type
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from PPoly:
 |  
 |  antiderivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the antiderivative.
 |      
 |      Antiderivative is also the indefinite integral of the function,
 |      and derivative is its inverse operation.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of antiderivative to evaluate. Default is 1, i.e. compute
 |          the first integral. If negative, the derivative is returned.
 |      
 |      Returns
 |      -------
 |      pp : PPoly
 |          Piecewise polynomial of order k2 = k + n representing
 |          the antiderivative of this polynomial.
 |      
 |      Notes
 |      -----
 |      The antiderivative returned by this function is continuous and
 |      continuously differentiable to order n-1, up to floating point
 |      rounding error.
 |      
 |      If antiderivative is computed and ``self.extrapolate='periodic'``,
 |      it will be set to False for the returned instance. This is done because
 |      the antiderivative is no longer periodic and its correct evaluation
 |      outside of the initially given x interval is difficult.
 |  
 |  derivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the derivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of derivative to evaluate. Default is 1, i.e. compute the
 |          first derivative. If negative, the antiderivative is returned.
 |      
 |      Returns
 |      -------
 |      pp : PPoly
 |          Piecewise polynomial of order k2 = k - n representing the derivative
 |          of this polynomial.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  integrate(self, a, b, extrapolate=None)
 |      Compute a definite integral over a piecewise polynomial.
 |      
 |      Parameters
 |      ----------
 |      a : float
 |          Lower integration bound
 |      b : float
 |          Upper integration bound
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      ig : array_like
 |          Definite integral of the piecewise polynomial over [a, b]
 |  
 |  roots(self, discontinuity=True, extrapolate=None)
 |      Find real roots of the the piecewise polynomial.
 |      
 |      Parameters
 |      ----------
 |      discontinuity : bool, optional
 |          Whether to report sign changes across discontinuities at
 |          breakpoints as roots.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to return roots from the polynomial
 |          extrapolated based on first and last intervals, 'periodic' works
 |          the same as False. If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      roots : ndarray
 |          Roots of the polynomial(s).
 |      
 |          If the PPoly object describes multiple polynomials, the
 |          return value is an object array whose each element is an
 |          ndarray containing the roots.
 |      
 |      See Also
 |      --------
 |      PPoly.solve
 |  
 |  solve(self, y=0.0, discontinuity=True, extrapolate=None)
 |      Find real solutions of the the equation ``pp(x) == y``.
 |      
 |      Parameters
 |      ----------
 |      y : float, optional
 |          Right-hand side. Default is zero.
 |      discontinuity : bool, optional
 |          Whether to report sign changes across discontinuities at
 |          breakpoints as roots.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to return roots from the polynomial
 |          extrapolated based on first and last intervals, 'periodic' works
 |          the same as False. If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      roots : ndarray
 |          Roots of the polynomial(s).
 |      
 |          If the PPoly object describes multiple polynomials, the
 |          return value is an object array whose each element is an
 |          ndarray containing the roots.
 |      
 |      Notes
 |      -----
 |      This routine works only on real-valued polynomials.
 |      
 |      If the piecewise polynomial contains sections that are
 |      identically zero, the root list will contain the start point
 |      of the corresponding interval, followed by a ``nan`` value.
 |      
 |      If the polynomial is discontinuous across a breakpoint, and
 |      there is a sign change across the breakpoint, this is reported
 |      if the `discont` parameter is True.
 |      
 |      Examples
 |      --------
 |      
 |      Finding roots of ``[x**2 - 1, (x - 1)**2]`` defined on intervals
 |      ``[-2, 1], [1, 2]``:
 |      
 |      >>> from scipy.interpolate import PPoly
 |      >>> pp = PPoly(np.array([[1, -4, 3], [1, 0, 0]]).T, [-2, 1, 2])
 |      >>> pp.roots()
 |      array([-1.,  1.])
 |  
 |  ----------------------------------------------------------------------
 |  Class methods inherited from PPoly:
 |  
 |  from_bernstein_basis(bp, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial in the power basis
 |      from a polynomial in Bernstein basis.
 |      
 |      Parameters
 |      ----------
 |      bp : BPoly
 |          A Bernstein basis polynomial, as created by BPoly
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |  
 |  from_spline(tck, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial from a spline
 |      
 |      Parameters
 |      ----------
 |      tck
 |          A spline, as returned by `splrep` or a BSpline object.
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from PPoly:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _PPolyBase:
 |  
 |  extend(self, c, x, right=None)
 |      Add additional breakpoints and coefficients to the polynomial.
 |      
 |      Parameters
 |      ----------
 |      c : ndarray, size (k, m, ...)
 |          Additional coefficients for polynomials in intervals. Note that
 |          the first additional interval will be formed using one of the
 |          `self.x` end points.
 |      x : ndarray, size (m,)
 |          Additional breakpoints. Must be sorted in the same order as
 |          `self.x` and either to the right or to the left of the current
 |          breakpoints.
 |      right
 |          Deprecated argument. Has no effect.
 |      
 |          .. deprecated:: 0.19
 |  
 |  ----------------------------------------------------------------------
 |  Class methods inherited from _PPolyBase:
 |  
 |  construct_fast(c, x, extrapolate=None, axis=0) from builtins.type
 |      Construct the piecewise polynomial without making checks.
 |      
 |      Takes the same parameters as the constructor. Input arguments
 |      `c` and `x` must be arrays of the correct shape and type.  The
 |      `c` array can only be of dtypes float and complex, and `x`
 |      array must have dtype float.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _PPolyBase:
 |  
 |  axis
 |  
 |  c
 |  
 |  extrapolate
 |  
 |  x
",class,"('(self, coeffs, breaks, fill=0.0, sort=False)',)",scipy,1.1.0,scipy.interpolate.interpolate._ppform,interpolate.interpolate,_ppform,"Python Library Documentation: class _ppform in module scipy.interpolate.interpolate

class _ppform(PPoly)
 |  Deprecated piecewise polynomial class.
 |  
 |  New code should use the `PPoly` class instead.
 |  
 |  Method resolution order:
 |      _ppform
 |      PPoly
 |      _PPolyBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __call__(self, x)
 |      Evaluate the piecewise polynomial or its derivative.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      nu : int, optional
 |          Order of derivative to evaluate. Must be non-negative.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  __init__(self, coeffs, breaks, fill=0.0, sort=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  fromspline(xk, cvals, order, fill=0.0) from builtins.type
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from PPoly:
 |  
 |  antiderivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the antiderivative.
 |      
 |      Antiderivative is also the indefinite integral of the function,
 |      and derivative is its inverse operation.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of antiderivative to evaluate. Default is 1, i.e. compute
 |          the first integral. If negative, the derivative is returned.
 |      
 |      Returns
 |      -------
 |      pp : PPoly
 |          Piecewise polynomial of order k2 = k + n representing
 |          the antiderivative of this polynomial.
 |      
 |      Notes
 |      -----
 |      The antiderivative returned by this function is continuous and
 |      continuously differentiable to order n-1, up to floating point
 |      rounding error.
 |      
 |      If antiderivative is computed and ``self.extrapolate='periodic'``,
 |      it will be set to False for the returned instance. This is done because
 |      the antiderivative is no longer periodic and its correct evaluation
 |      outside of the initially given x interval is difficult.
 |  
 |  derivative(self, nu=1)
 |      Construct a new piecewise polynomial representing the derivative.
 |      
 |      Parameters
 |      ----------
 |      nu : int, optional
 |          Order of derivative to evaluate. Default is 1, i.e. compute the
 |          first derivative. If negative, the antiderivative is returned.
 |      
 |      Returns
 |      -------
 |      pp : PPoly
 |          Piecewise polynomial of order k2 = k - n representing the derivative
 |          of this polynomial.
 |      
 |      Notes
 |      -----
 |      Derivatives are evaluated piecewise for each polynomial
 |      segment, even if the polynomial is not differentiable at the
 |      breakpoints. The polynomial intervals are considered half-open,
 |      ``[a, b)``, except for the last interval which is closed
 |      ``[a, b]``.
 |  
 |  integrate(self, a, b, extrapolate=None)
 |      Compute a definite integral over a piecewise polynomial.
 |      
 |      Parameters
 |      ----------
 |      a : float
 |          Lower integration bound
 |      b : float
 |          Upper integration bound
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used.
 |          If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      ig : array_like
 |          Definite integral of the piecewise polynomial over [a, b]
 |  
 |  roots(self, discontinuity=True, extrapolate=None)
 |      Find real roots of the the piecewise polynomial.
 |      
 |      Parameters
 |      ----------
 |      discontinuity : bool, optional
 |          Whether to report sign changes across discontinuities at
 |          breakpoints as roots.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to return roots from the polynomial
 |          extrapolated based on first and last intervals, 'periodic' works
 |          the same as False. If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      roots : ndarray
 |          Roots of the polynomial(s).
 |      
 |          If the PPoly object describes multiple polynomials, the
 |          return value is an object array whose each element is an
 |          ndarray containing the roots.
 |      
 |      See Also
 |      --------
 |      PPoly.solve
 |  
 |  solve(self, y=0.0, discontinuity=True, extrapolate=None)
 |      Find real solutions of the the equation ``pp(x) == y``.
 |      
 |      Parameters
 |      ----------
 |      y : float, optional
 |          Right-hand side. Default is zero.
 |      discontinuity : bool, optional
 |          Whether to report sign changes across discontinuities at
 |          breakpoints as roots.
 |      extrapolate : {bool, 'periodic', None}, optional
 |          If bool, determines whether to return roots from the polynomial
 |          extrapolated based on first and last intervals, 'periodic' works
 |          the same as False. If None (default), use `self.extrapolate`.
 |      
 |      Returns
 |      -------
 |      roots : ndarray
 |          Roots of the polynomial(s).
 |      
 |          If the PPoly object describes multiple polynomials, the
 |          return value is an object array whose each element is an
 |          ndarray containing the roots.
 |      
 |      Notes
 |      -----
 |      This routine works only on real-valued polynomials.
 |      
 |      If the piecewise polynomial contains sections that are
 |      identically zero, the root list will contain the start point
 |      of the corresponding interval, followed by a ``nan`` value.
 |      
 |      If the polynomial is discontinuous across a breakpoint, and
 |      there is a sign change across the breakpoint, this is reported
 |      if the `discont` parameter is True.
 |      
 |      Examples
 |      --------
 |      
 |      Finding roots of ``[x**2 - 1, (x - 1)**2]`` defined on intervals
 |      ``[-2, 1], [1, 2]``:
 |      
 |      >>> from scipy.interpolate import PPoly
 |      >>> pp = PPoly(np.array([[1, -4, 3], [1, 0, 0]]).T, [-2, 1, 2])
 |      >>> pp.roots()
 |      array([-1.,  1.])
 |  
 |  ----------------------------------------------------------------------
 |  Class methods inherited from PPoly:
 |  
 |  from_bernstein_basis(bp, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial in the power basis
 |      from a polynomial in Bernstein basis.
 |      
 |      Parameters
 |      ----------
 |      bp : BPoly
 |          A Bernstein basis polynomial, as created by BPoly
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |  
 |  from_spline(tck, extrapolate=None) from builtins.type
 |      Construct a piecewise polynomial from a spline
 |      
 |      Parameters
 |      ----------
 |      tck
 |          A spline, as returned by `splrep` or a BSpline object.
 |      extrapolate : bool or 'periodic', optional
 |          If bool, determines whether to extrapolate to out-of-bounds points
 |          based on first and last intervals, or to return NaNs.
 |          If 'periodic', periodic extrapolation is used. Default is True.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from PPoly:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _PPolyBase:
 |  
 |  extend(self, c, x, right=None)
 |      Add additional breakpoints and coefficients to the polynomial.
 |      
 |      Parameters
 |      ----------
 |      c : ndarray, size (k, m, ...)
 |          Additional coefficients for polynomials in intervals. Note that
 |          the first additional interval will be formed using one of the
 |          `self.x` end points.
 |      x : ndarray, size (m,)
 |          Additional breakpoints. Must be sorted in the same order as
 |          `self.x` and either to the right or to the left of the current
 |          breakpoints.
 |      right
 |          Deprecated argument. Has no effect.
 |      
 |          .. deprecated:: 0.19
 |  
 |  ----------------------------------------------------------------------
 |  Class methods inherited from _PPolyBase:
 |  
 |  construct_fast(c, x, extrapolate=None, axis=0) from builtins.type
 |      Construct the piecewise polynomial without making checks.
 |      
 |      Takes the same parameters as the constructor. Input arguments
 |      `c` and `x` must be arrays of the correct shape and type.  The
 |      `c` array can only be of dtypes float and complex, and `x`
 |      array must have dtype float.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _PPolyBase:
 |  
 |  axis
 |  
 |  c
 |  
 |  extrapolate
 |  
 |  x
",class,"('self', 'coeffs', 'breaks', 'fill', 'sort')","(nan, nan, nan, 0.0, False)","(nan, nan, nan, 'float', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, coeffs, breaks, fill=0.0, sort=False)',)"
scipy,1.1.0,scipy.interpolate.interpolate._ppform.construct_fast,interpolate.interpolate._ppform,construct_fast,"Python Library Documentation: method construct_fast in module scipy.interpolate.interpolate

construct_fast(c, x, extrapolate=None, axis=0) method of builtins.type instance
    Construct the piecewise polynomial without making checks.
    
    Takes the same parameters as the constructor. Input arguments
    `c` and `x` must be arrays of the correct shape and type.  The
    `c` array can only be of dtypes float and complex, and `x`
    array must have dtype float.
",method,"('(c, x, extrapolate=None, axis=0)',)",scipy,1.1.0,scipy.interpolate.interpolate._ppform.construct_fast,interpolate.interpolate._ppform,construct_fast,"Python Library Documentation: method construct_fast in module scipy.interpolate.interpolate

construct_fast(c, x, extrapolate=None, axis=0) method of builtins.type instance
    Construct the piecewise polynomial without making checks.
    
    Takes the same parameters as the constructor. Input arguments
    `c` and `x` must be arrays of the correct shape and type.  The
    `c` array can only be of dtypes float and complex, and `x`
    array must have dtype float.
",method,"('cls', 'c', 'x', 'extrapolate', 'axis')","(nan, nan, nan, None, 0)","(nan, nan, nan, 'NoneType', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(c, x, extrapolate=None, axis=0)',)"
scipy,1.1.0,scipy.interpolate.interpolate._ppform.from_bernstein_basis,interpolate.interpolate._ppform,from_bernstein_basis,"Python Library Documentation: method from_bernstein_basis in module scipy.interpolate.interpolate

from_bernstein_basis(bp, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial in the power basis
    from a polynomial in Bernstein basis.
    
    Parameters
    ----------
    bp : BPoly
        A Bernstein basis polynomial, as created by BPoly
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
",method,"('(bp, extrapolate=None)',)",scipy,1.1.0,scipy.interpolate.interpolate._ppform.from_bernstein_basis,interpolate.interpolate._ppform,from_bernstein_basis,"Python Library Documentation: method from_bernstein_basis in module scipy.interpolate.interpolate

from_bernstein_basis(bp, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial in the power basis
    from a polynomial in Bernstein basis.
    
    Parameters
    ----------
    bp : BPoly
        A Bernstein basis polynomial, as created by BPoly
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
",method,"('cls', 'bp', 'extrapolate')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(bp, extrapolate=None)',)"
scipy,1.1.0,scipy.interpolate.interpolate._ppform.from_spline,interpolate.interpolate._ppform,from_spline,"Python Library Documentation: method from_spline in module scipy.interpolate.interpolate

from_spline(tck, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial from a spline
    
    Parameters
    ----------
    tck
        A spline, as returned by `splrep` or a BSpline object.
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
",method,"('(tck, extrapolate=None)',)",scipy,1.1.0,scipy.interpolate.interpolate._ppform.from_spline,interpolate.interpolate._ppform,from_spline,"Python Library Documentation: method from_spline in module scipy.interpolate.interpolate

from_spline(tck, extrapolate=None) method of builtins.type instance
    Construct a piecewise polynomial from a spline
    
    Parameters
    ----------
    tck
        A spline, as returned by `splrep` or a BSpline object.
    extrapolate : bool or 'periodic', optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs.
        If 'periodic', periodic extrapolation is used. Default is True.
",method,"('cls', 'tck', 'extrapolate')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(tck, extrapolate=None)',)"
scipy,1.1.0,scipy.interpolate.interpolate._ppform.fromspline,interpolate.interpolate._ppform,fromspline,"Python Library Documentation: method fromspline in module scipy.interpolate.interpolate

fromspline(xk, cvals, order, fill=0.0) method of builtins.type instance
",method,"('(xk, cvals, order, fill=0.0)',)",scipy,1.1.0,scipy.interpolate.interpolate._ppform.fromspline,interpolate.interpolate._ppform,fromspline,"Python Library Documentation: method fromspline in module scipy.interpolate.interpolate

fromspline(xk, cvals, order, fill=0.0) method of builtins.type instance
",method,"('cls', 'xk', 'cvals', 'order', 'fill')","(nan, nan, nan, nan, 0.0)","(nan, nan, nan, nan, 'float')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(xk, cvals, order, fill=0.0)',)"
scipy,1.1.0,scipy.interpolate.interpolate.asarray,interpolate.interpolate,asarray,"Python Library Documentation: function asarray in module numpy.core.numeric

asarray(a, dtype=None, order=None)
    Convert the input to an array.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
        Whether to use row-major (C-style) or
        column-major (Fortran-style) memory representation.
        Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray with matching dtype and order.  If `a` is a
        subclass of ndarray, a base class ndarray is returned.
    
    See Also
    --------
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    asarray_chkfinite : Similar function which checks input for NaNs and Infs.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array:
    
    >>> a = [1, 2]
    >>> np.asarray(a)
    array([1, 2])
    
    Existing arrays are not copied:
    
    >>> a = np.array([1, 2])
    >>> np.asarray(a) is a
    True
    
    If `dtype` is set, array is copied only if dtype does not match:
    
    >>> a = np.array([1, 2], dtype=np.float32)
    >>> np.asarray(a, dtype=np.float32) is a
    True
    >>> np.asarray(a, dtype=np.float64) is a
    False
    
    Contrary to `asanyarray`, ndarray subclasses are not passed through:
    
    >>> issubclass(np.matrix, np.ndarray)
    True
    >>> a = np.matrix([[1, 2]])
    >>> np.asarray(a) is a
    False
    >>> np.asanyarray(a) is a
    True
",function,"('(a, dtype=None, order=None)',)",scipy,1.1.0,scipy.interpolate.interpolate.asarray,interpolate.interpolate,asarray,"Python Library Documentation: function asarray in module numpy.core.numeric

asarray(a, dtype=None, order=None)
    Convert the input to an array.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
        Whether to use row-major (C-style) or
        column-major (Fortran-style) memory representation.
        Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray with matching dtype and order.  If `a` is a
        subclass of ndarray, a base class ndarray is returned.
    
    See Also
    --------
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    asarray_chkfinite : Similar function which checks input for NaNs and Infs.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array:
    
    >>> a = [1, 2]
    >>> np.asarray(a)
    array([1, 2])
    
    Existing arrays are not copied:
    
    >>> a = np.array([1, 2])
    >>> np.asarray(a) is a
    True
    
    If `dtype` is set, array is copied only if dtype does not match:
    
    >>> a = np.array([1, 2], dtype=np.float32)
    >>> np.asarray(a, dtype=np.float32) is a
    True
    >>> np.asarray(a, dtype=np.float64) is a
    False
    
    Contrary to `asanyarray`, ndarray subclasses are not passed through:
    
    >>> issubclass(np.matrix, np.ndarray)
    True
    >>> a = np.matrix([[1, 2]])
    >>> np.asarray(a) is a
    False
    >>> np.asanyarray(a) is a
    True
",function,"('a', 'dtype', 'order')","(nan, None, None)","(nan, 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(a, dtype=None, order=None)',)"
scipy,1.1.0,scipy.interpolate.interpolate.atleast_1d,interpolate.interpolate,atleast_1d,"Python Library Documentation: function atleast_1d in module numpy.core.shape_base

atleast_1d(*arys)
    Convert inputs to arrays with at least one dimension.
    
    Scalar inputs are converted to 1-dimensional arrays, whilst
    higher-dimensional inputs are preserved.
    
    Parameters
    ----------
    arys1, arys2, ... : array_like
        One or more input arrays.
    
    Returns
    -------
    ret : ndarray
        An array, or list of arrays, each with ``a.ndim >= 1``.
        Copies are made only if necessary.
    
    See Also
    --------
    atleast_2d, atleast_3d
    
    Examples
    --------
    >>> np.atleast_1d(1.0)
    array([ 1.])
    
    >>> x = np.arange(9.0).reshape(3,3)
    >>> np.atleast_1d(x)
    array([[ 0.,  1.,  2.],
           [ 3.,  4.,  5.],
           [ 6.,  7.,  8.]])
    >>> np.atleast_1d(x) is x
    True
    
    >>> np.atleast_1d(1, [3, 4])
    [array([1]), array([3, 4])]
",function,"('(*arys)',)",scipy,1.1.0,scipy.interpolate.interpolate.atleast_1d,interpolate.interpolate,atleast_1d,"Python Library Documentation: function atleast_1d in module numpy.core.shape_base

atleast_1d(*arys)
    Convert inputs to arrays with at least one dimension.
    
    Scalar inputs are converted to 1-dimensional arrays, whilst
    higher-dimensional inputs are preserved.
    
    Parameters
    ----------
    arys1, arys2, ... : array_like
        One or more input arrays.
    
    Returns
    -------
    ret : ndarray
        An array, or list of arrays, each with ``a.ndim >= 1``.
        Copies are made only if necessary.
    
    See Also
    --------
    atleast_2d, atleast_3d
    
    Examples
    --------
    >>> np.atleast_1d(1.0)
    array([ 1.])
    
    >>> x = np.arange(9.0).reshape(3,3)
    >>> np.atleast_1d(x)
    array([[ 0.,  1.,  2.],
           [ 3.,  4.,  5.],
           [ 6.,  7.,  8.]])
    >>> np.atleast_1d(x) is x
    True
    
    >>> np.atleast_1d(1, [3, 4])
    [array([1]), array([3, 4])]
",function,(),(),(),(),"('(*arys)',)"
scipy,1.1.0,scipy.interpolate.interpolate.atleast_2d,interpolate.interpolate,atleast_2d,"Python Library Documentation: function atleast_2d in module numpy.core.shape_base

atleast_2d(*arys)
    View inputs as arrays with at least two dimensions.
    
    Parameters
    ----------
    arys1, arys2, ... : array_like
        One or more array-like sequences.  Non-array inputs are converted
        to arrays.  Arrays that already have two or more dimensions are
        preserved.
    
    Returns
    -------
    res, res2, ... : ndarray
        An array, or list of arrays, each with ``a.ndim >= 2``.
        Copies are avoided where possible, and views with two or more
        dimensions are returned.
    
    See Also
    --------
    atleast_1d, atleast_3d
    
    Examples
    --------
    >>> np.atleast_2d(3.0)
    array([[ 3.]])
    
    >>> x = np.arange(3.0)
    >>> np.atleast_2d(x)
    array([[ 0.,  1.,  2.]])
    >>> np.atleast_2d(x).base is x
    True
    
    >>> np.atleast_2d(1, [1, 2], [[1, 2]])
    [array([[1]]), array([[1, 2]]), array([[1, 2]])]
",function,"('(*arys)',)",scipy,1.1.0,scipy.interpolate.interpolate.atleast_2d,interpolate.interpolate,atleast_2d,"Python Library Documentation: function atleast_2d in module numpy.core.shape_base

atleast_2d(*arys)
    View inputs as arrays with at least two dimensions.
    
    Parameters
    ----------
    arys1, arys2, ... : array_like
        One or more array-like sequences.  Non-array inputs are converted
        to arrays.  Arrays that already have two or more dimensions are
        preserved.
    
    Returns
    -------
    res, res2, ... : ndarray
        An array, or list of arrays, each with ``a.ndim >= 2``.
        Copies are avoided where possible, and views with two or more
        dimensions are returned.
    
    See Also
    --------
    atleast_1d, atleast_3d
    
    Examples
    --------
    >>> np.atleast_2d(3.0)
    array([[ 3.]])
    
    >>> x = np.arange(3.0)
    >>> np.atleast_2d(x)
    array([[ 0.,  1.,  2.]])
    >>> np.atleast_2d(x).base is x
    True
    
    >>> np.atleast_2d(1, [1, 2], [[1, 2]])
    [array([[1]]), array([[1, 2]]), array([[1, 2]])]
",function,(),(),(),(),"('(*arys)',)"
scipy,1.1.0,scipy.interpolate.interpolate.comb,interpolate.interpolate,comb,"Python Library Documentation: function comb in module scipy.special.basic

comb(N, k, exact=False, repetition=False)
    The number of combinations of N things taken k at a time.
    
    This is often expressed as ""N choose k"".
    
    Parameters
    ----------
    N : int, ndarray
        Number of things.
    k : int, ndarray
        Number of elements taken.
    exact : bool, optional
        If `exact` is False, then floating point precision is used, otherwise
        exact long integer is computed.
    repetition : bool, optional
        If `repetition` is True, then the number of combinations with
        repetition is computed.
    
    Returns
    -------
    val : int, float, ndarray
        The total number of combinations.
    
    See Also
    --------
    binom : Binomial coefficient ufunc
    
    Notes
    -----
    - Array arguments accepted only for exact=False case.
    - If k > N, N < 0, or k < 0, then a 0 is returned.
    
    Examples
    --------
    >>> from scipy.special import comb
    >>> k = np.array([3, 4])
    >>> n = np.array([10, 10])
    >>> comb(n, k, exact=False)
    array([ 120.,  210.])
    >>> comb(10, 3, exact=True)
    120L
    >>> comb(10, 3, exact=True, repetition=True)
    220L
",function,"('(N, k, exact=False, repetition=False)',)",scipy,1.1.0,scipy.interpolate.interpolate.comb,interpolate.interpolate,comb,"Python Library Documentation: function comb in module scipy.special.basic

comb(N, k, exact=False, repetition=False)
    The number of combinations of N things taken k at a time.
    
    This is often expressed as ""N choose k"".
    
    Parameters
    ----------
    N : int, ndarray
        Number of things.
    k : int, ndarray
        Number of elements taken.
    exact : bool, optional
        If `exact` is False, then floating point precision is used, otherwise
        exact long integer is computed.
    repetition : bool, optional
        If `repetition` is True, then the number of combinations with
        repetition is computed.
    
    Returns
    -------
    val : int, float, ndarray
        The total number of combinations.
    
    See Also
    --------
    binom : Binomial coefficient ufunc
    
    Notes
    -----
    - Array arguments accepted only for exact=False case.
    - If k > N, N < 0, or k < 0, then a 0 is returned.
    
    Examples
    --------
    >>> from scipy.special import comb
    >>> k = np.array([3, 4])
    >>> n = np.array([10, 10])
    >>> comb(n, k, exact=False)
    array([ 120.,  210.])
    >>> comb(10, 3, exact=True)
    120L
    >>> comb(10, 3, exact=True, repetition=True)
    220L
",function,"('N', 'k', 'exact', 'repetition')","(nan, nan, False, False)","(nan, nan, 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(N, k, exact=False, repetition=False)',)"
scipy,1.1.0,scipy.interpolate.interpolate.interp1d,interpolate.interpolate,interp1d,"Python Library Documentation: class interp1d in module scipy.interpolate.interpolate

class interp1d(scipy.interpolate.polyint._Interpolator1D)
 |  Interpolate a 1-D function.
 |  
 |  `x` and `y` are arrays of values used to approximate some function f:
 |  ``y = f(x)``.  This class returns a function whose call method uses
 |  interpolation to find the value of new points.
 |  
 |  Note that calling `interp1d` with NaNs present in input values results in
 |  undefined behaviour.
 |  
 |  Parameters
 |  ----------
 |  x : (N,) array_like
 |      A 1-D array of real values.
 |  y : (...,N,...) array_like
 |      A N-D array of real values. The length of `y` along the interpolation
 |      axis must be equal to the length of `x`.
 |  kind : str or int, optional
 |      Specifies the kind of interpolation as a string
 |      ('linear', 'nearest', 'zero', 'slinear', 'quadratic', 'cubic',
 |      'previous', 'next', where 'zero', 'slinear', 'quadratic' and 'cubic'
 |      refer to a spline interpolation of zeroth, first, second or third
 |      order; 'previous' and 'next' simply return the previous or next value
 |      of the point) or as an integer specifying the order of the spline
 |      interpolator to use.
 |      Default is 'linear'.
 |  axis : int, optional
 |      Specifies the axis of `y` along which to interpolate.
 |      Interpolation defaults to the last axis of `y`.
 |  copy : bool, optional
 |      If True, the class makes internal copies of x and y.
 |      If False, references to `x` and `y` are used. The default is to copy.
 |  bounds_error : bool, optional
 |      If True, a ValueError is raised any time interpolation is attempted on
 |      a value outside of the range of x (where extrapolation is
 |      necessary). If False, out of bounds values are assigned `fill_value`.
 |      By default, an error is raised unless `fill_value=""extrapolate""`.
 |  fill_value : array-like or (array-like, array_like) or ""extrapolate"", optional
 |      - if a ndarray (or float), this value will be used to fill in for
 |        requested points outside of the data range. If not provided, then
 |        the default is NaN. The array-like must broadcast properly to the
 |        dimensions of the non-interpolation axes.
 |      - If a two-element tuple, then the first element is used as a
 |        fill value for ``x_new < x[0]`` and the second element is used for
 |        ``x_new > x[-1]``. Anything that is not a 2-element tuple (e.g.,
 |        list or ndarray, regardless of shape) is taken to be a single
 |        array-like argument meant to be used for both bounds as
 |        ``below, above = fill_value, fill_value``.
 |  
 |        .. versionadded:: 0.17.0
 |      - If ""extrapolate"", then points outside the data range will be
 |        extrapolated.
 |  
 |        .. versionadded:: 0.17.0
 |  assume_sorted : bool, optional
 |      If False, values of `x` can be in any order and they are sorted first.
 |      If True, `x` has to be an array of monotonically increasing values.
 |  
 |  Methods
 |  -------
 |  __call__
 |  
 |  See Also
 |  --------
 |  splrep, splev
 |      Spline interpolation/smoothing based on FITPACK.
 |  UnivariateSpline : An object-oriented wrapper of the FITPACK routines.
 |  interp2d : 2-D interpolation
 |  
 |  Examples
 |  --------
 |  >>> import matplotlib.pyplot as plt
 |  >>> from scipy import interpolate
 |  >>> x = np.arange(0, 10)
 |  >>> y = np.exp(-x/3.0)
 |  >>> f = interpolate.interp1d(x, y)
 |  
 |  >>> xnew = np.arange(0, 9, 0.1)
 |  >>> ynew = f(xnew)   # use interpolation function returned by `interp1d`
 |  >>> plt.plot(x, y, 'o', xnew, ynew, '-')
 |  >>> plt.show()
 |  
 |  Method resolution order:
 |      interp1d
 |      scipy.interpolate.polyint._Interpolator1D
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, x, y, kind='linear', axis=-1, copy=True, bounds_error=None, fill_value=nan, assume_sorted=False)
 |      Initialize a 1D linear interpolation class.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  fill_value
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.interpolate.polyint._Interpolator1D:
 |  
 |  __call__(self, x)
 |      Evaluate the interpolant
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.interpolate.polyint._Interpolator1D:
 |  
 |  dtype
",class,"(""(self, x, y, kind='linear', axis=-1, copy=True, bounds_error=None, fill_value=nan, assume_sorted=False)"",)",scipy,1.1.0,scipy.interpolate.interpolate.interp1d,interpolate.interpolate,interp1d,"Python Library Documentation: class interp1d in module scipy.interpolate.interpolate

class interp1d(scipy.interpolate.polyint._Interpolator1D)
 |  Interpolate a 1-D function.
 |  
 |  `x` and `y` are arrays of values used to approximate some function f:
 |  ``y = f(x)``.  This class returns a function whose call method uses
 |  interpolation to find the value of new points.
 |  
 |  Note that calling `interp1d` with NaNs present in input values results in
 |  undefined behaviour.
 |  
 |  Parameters
 |  ----------
 |  x : (N,) array_like
 |      A 1-D array of real values.
 |  y : (...,N,...) array_like
 |      A N-D array of real values. The length of `y` along the interpolation
 |      axis must be equal to the length of `x`.
 |  kind : str or int, optional
 |      Specifies the kind of interpolation as a string
 |      ('linear', 'nearest', 'zero', 'slinear', 'quadratic', 'cubic',
 |      'previous', 'next', where 'zero', 'slinear', 'quadratic' and 'cubic'
 |      refer to a spline interpolation of zeroth, first, second or third
 |      order; 'previous' and 'next' simply return the previous or next value
 |      of the point) or as an integer specifying the order of the spline
 |      interpolator to use.
 |      Default is 'linear'.
 |  axis : int, optional
 |      Specifies the axis of `y` along which to interpolate.
 |      Interpolation defaults to the last axis of `y`.
 |  copy : bool, optional
 |      If True, the class makes internal copies of x and y.
 |      If False, references to `x` and `y` are used. The default is to copy.
 |  bounds_error : bool, optional
 |      If True, a ValueError is raised any time interpolation is attempted on
 |      a value outside of the range of x (where extrapolation is
 |      necessary). If False, out of bounds values are assigned `fill_value`.
 |      By default, an error is raised unless `fill_value=""extrapolate""`.
 |  fill_value : array-like or (array-like, array_like) or ""extrapolate"", optional
 |      - if a ndarray (or float), this value will be used to fill in for
 |        requested points outside of the data range. If not provided, then
 |        the default is NaN. The array-like must broadcast properly to the
 |        dimensions of the non-interpolation axes.
 |      - If a two-element tuple, then the first element is used as a
 |        fill value for ``x_new < x[0]`` and the second element is used for
 |        ``x_new > x[-1]``. Anything that is not a 2-element tuple (e.g.,
 |        list or ndarray, regardless of shape) is taken to be a single
 |        array-like argument meant to be used for both bounds as
 |        ``below, above = fill_value, fill_value``.
 |  
 |        .. versionadded:: 0.17.0
 |      - If ""extrapolate"", then points outside the data range will be
 |        extrapolated.
 |  
 |        .. versionadded:: 0.17.0
 |  assume_sorted : bool, optional
 |      If False, values of `x` can be in any order and they are sorted first.
 |      If True, `x` has to be an array of monotonically increasing values.
 |  
 |  Methods
 |  -------
 |  __call__
 |  
 |  See Also
 |  --------
 |  splrep, splev
 |      Spline interpolation/smoothing based on FITPACK.
 |  UnivariateSpline : An object-oriented wrapper of the FITPACK routines.
 |  interp2d : 2-D interpolation
 |  
 |  Examples
 |  --------
 |  >>> import matplotlib.pyplot as plt
 |  >>> from scipy import interpolate
 |  >>> x = np.arange(0, 10)
 |  >>> y = np.exp(-x/3.0)
 |  >>> f = interpolate.interp1d(x, y)
 |  
 |  >>> xnew = np.arange(0, 9, 0.1)
 |  >>> ynew = f(xnew)   # use interpolation function returned by `interp1d`
 |  >>> plt.plot(x, y, 'o', xnew, ynew, '-')
 |  >>> plt.show()
 |  
 |  Method resolution order:
 |      interp1d
 |      scipy.interpolate.polyint._Interpolator1D
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, x, y, kind='linear', axis=-1, copy=True, bounds_error=None, fill_value=nan, assume_sorted=False)
 |      Initialize a 1D linear interpolation class.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  fill_value
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.interpolate.polyint._Interpolator1D:
 |  
 |  __call__(self, x)
 |      Evaluate the interpolant
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.interpolate.polyint._Interpolator1D:
 |  
 |  dtype
",class,"('self', 'x', 'y', 'kind', 'axis', 'copy', 'bounds_error', 'fill_value', 'assume_sorted')","(nan, nan, nan, 'linear', -1, True, None, nan, False)","(nan, nan, nan, 'str', 'int', 'bool', 'NoneType', nan, 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(self, x, y, kind='linear', axis=-1, copy=True, bounds_error=None, fill_value=nan, assume_sorted=False)"",)"
scipy,1.1.0,scipy.interpolate.interpolate.interp2d,interpolate.interpolate,interp2d,"Python Library Documentation: class interp2d in module scipy.interpolate.interpolate

class interp2d(builtins.object)
 |  interp2d(x, y, z, kind='linear', copy=True, bounds_error=False,
 |           fill_value=nan)
 |  
 |  Interpolate over a 2-D grid.
 |  
 |  `x`, `y` and `z` are arrays of values used to approximate some function
 |  f: ``z = f(x, y)``. This class returns a function whose call method uses
 |  spline interpolation to find the value of new points.
 |  
 |  If `x` and `y` represent a regular grid, consider using
 |  RectBivariateSpline.
 |  
 |  Note that calling `interp2d` with NaNs present in input values results in
 |  undefined behaviour.
 |  
 |  Methods
 |  -------
 |  __call__
 |  
 |  Parameters
 |  ----------
 |  x, y : array_like
 |      Arrays defining the data point coordinates.
 |  
 |      If the points lie on a regular grid, `x` can specify the column
 |      coordinates and `y` the row coordinates, for example::
 |  
 |        >>> x = [0,1,2];  y = [0,3]; z = [[1,2,3], [4,5,6]]
 |  
 |      Otherwise, `x` and `y` must specify the full coordinates for each
 |      point, for example::
 |  
 |        >>> x = [0,1,2,0,1,2];  y = [0,0,0,3,3,3]; z = [1,2,3,4,5,6]
 |  
 |      If `x` and `y` are multi-dimensional, they are flattened before use.
 |  z : array_like
 |      The values of the function to interpolate at the data points. If
 |      `z` is a multi-dimensional array, it is flattened before use.  The
 |      length of a flattened `z` array is either
 |      len(`x`)*len(`y`) if `x` and `y` specify the column and row coordinates
 |      or ``len(z) == len(x) == len(y)`` if `x` and `y` specify coordinates
 |      for each point.
 |  kind : {'linear', 'cubic', 'quintic'}, optional
 |      The kind of spline interpolation to use. Default is 'linear'.
 |  copy : bool, optional
 |      If True, the class makes internal copies of x, y and z.
 |      If False, references may be used. The default is to copy.
 |  bounds_error : bool, optional
 |      If True, when interpolated values are requested outside of the
 |      domain of the input data (x,y), a ValueError is raised.
 |      If False, then `fill_value` is used.
 |  fill_value : number, optional
 |      If provided, the value to use for points outside of the
 |      interpolation domain. If omitted (None), values outside
 |      the domain are extrapolated.
 |  
 |  See Also
 |  --------
 |  RectBivariateSpline :
 |      Much faster 2D interpolation if your input data is on a grid
 |  bisplrep, bisplev :
 |      Spline interpolation based on FITPACK
 |  BivariateSpline : a more recent wrapper of the FITPACK routines
 |  interp1d : one dimension version of this function
 |  
 |  Notes
 |  -----
 |  The minimum number of data points required along the interpolation
 |  axis is ``(k+1)**2``, with k=1 for linear, k=3 for cubic and k=5 for
 |  quintic interpolation.
 |  
 |  The interpolator is constructed by `bisplrep`, with a smoothing factor
 |  of 0. If more control over smoothing is needed, `bisplrep` should be
 |  used directly.
 |  
 |  Examples
 |  --------
 |  Construct a 2-D grid and interpolate on it:
 |  
 |  >>> from scipy import interpolate
 |  >>> x = np.arange(-5.01, 5.01, 0.25)
 |  >>> y = np.arange(-5.01, 5.01, 0.25)
 |  >>> xx, yy = np.meshgrid(x, y)
 |  >>> z = np.sin(xx**2+yy**2)
 |  >>> f = interpolate.interp2d(x, y, z, kind='cubic')
 |  
 |  Now use the obtained interpolation function and plot the result:
 |  
 |  >>> import matplotlib.pyplot as plt
 |  >>> xnew = np.arange(-5.01, 5.01, 1e-2)
 |  >>> ynew = np.arange(-5.01, 5.01, 1e-2)
 |  >>> znew = f(xnew, ynew)
 |  >>> plt.plot(x, z[0, :], 'ro-', xnew, znew[0, :], 'b-')
 |  >>> plt.show()
 |  
 |  Methods defined here:
 |  
 |  __call__(self, x, y, dx=0, dy=0, assume_sorted=False)
 |      Interpolate the function.
 |      
 |      Parameters
 |      ----------
 |      x : 1D array
 |          x-coordinates of the mesh on which to interpolate.
 |      y : 1D array
 |          y-coordinates of the mesh on which to interpolate.
 |      dx : int >= 0, < kx
 |          Order of partial derivatives in x.
 |      dy : int >= 0, < ky
 |          Order of partial derivatives in y.
 |      assume_sorted : bool, optional
 |          If False, values of `x` and `y` can be in any order and they are
 |          sorted first.
 |          If True, `x` and `y` have to be arrays of monotonically
 |          increasing values.
 |      
 |      Returns
 |      -------
 |      z : 2D array with shape (len(y), len(x))
 |          The interpolated values.
 |  
 |  __init__(self, x, y, z, kind='linear', copy=True, bounds_error=False, fill_value=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"(""(self, x, y, z, kind='linear', copy=True, bounds_error=False, fill_value=None)"",)",scipy,1.1.0,scipy.interpolate.interpolate.interp2d,interpolate.interpolate,interp2d,"Python Library Documentation: class interp2d in module scipy.interpolate.interpolate

class interp2d(builtins.object)
 |  interp2d(x, y, z, kind='linear', copy=True, bounds_error=False,
 |           fill_value=nan)
 |  
 |  Interpolate over a 2-D grid.
 |  
 |  `x`, `y` and `z` are arrays of values used to approximate some function
 |  f: ``z = f(x, y)``. This class returns a function whose call method uses
 |  spline interpolation to find the value of new points.
 |  
 |  If `x` and `y` represent a regular grid, consider using
 |  RectBivariateSpline.
 |  
 |  Note that calling `interp2d` with NaNs present in input values results in
 |  undefined behaviour.
 |  
 |  Methods
 |  -------
 |  __call__
 |  
 |  Parameters
 |  ----------
 |  x, y : array_like
 |      Arrays defining the data point coordinates.
 |  
 |      If the points lie on a regular grid, `x` can specify the column
 |      coordinates and `y` the row coordinates, for example::
 |  
 |        >>> x = [0,1,2];  y = [0,3]; z = [[1,2,3], [4,5,6]]
 |  
 |      Otherwise, `x` and `y` must specify the full coordinates for each
 |      point, for example::
 |  
 |        >>> x = [0,1,2,0,1,2];  y = [0,0,0,3,3,3]; z = [1,2,3,4,5,6]
 |  
 |      If `x` and `y` are multi-dimensional, they are flattened before use.
 |  z : array_like
 |      The values of the function to interpolate at the data points. If
 |      `z` is a multi-dimensional array, it is flattened before use.  The
 |      length of a flattened `z` array is either
 |      len(`x`)*len(`y`) if `x` and `y` specify the column and row coordinates
 |      or ``len(z) == len(x) == len(y)`` if `x` and `y` specify coordinates
 |      for each point.
 |  kind : {'linear', 'cubic', 'quintic'}, optional
 |      The kind of spline interpolation to use. Default is 'linear'.
 |  copy : bool, optional
 |      If True, the class makes internal copies of x, y and z.
 |      If False, references may be used. The default is to copy.
 |  bounds_error : bool, optional
 |      If True, when interpolated values are requested outside of the
 |      domain of the input data (x,y), a ValueError is raised.
 |      If False, then `fill_value` is used.
 |  fill_value : number, optional
 |      If provided, the value to use for points outside of the
 |      interpolation domain. If omitted (None), values outside
 |      the domain are extrapolated.
 |  
 |  See Also
 |  --------
 |  RectBivariateSpline :
 |      Much faster 2D interpolation if your input data is on a grid
 |  bisplrep, bisplev :
 |      Spline interpolation based on FITPACK
 |  BivariateSpline : a more recent wrapper of the FITPACK routines
 |  interp1d : one dimension version of this function
 |  
 |  Notes
 |  -----
 |  The minimum number of data points required along the interpolation
 |  axis is ``(k+1)**2``, with k=1 for linear, k=3 for cubic and k=5 for
 |  quintic interpolation.
 |  
 |  The interpolator is constructed by `bisplrep`, with a smoothing factor
 |  of 0. If more control over smoothing is needed, `bisplrep` should be
 |  used directly.
 |  
 |  Examples
 |  --------
 |  Construct a 2-D grid and interpolate on it:
 |  
 |  >>> from scipy import interpolate
 |  >>> x = np.arange(-5.01, 5.01, 0.25)
 |  >>> y = np.arange(-5.01, 5.01, 0.25)
 |  >>> xx, yy = np.meshgrid(x, y)
 |  >>> z = np.sin(xx**2+yy**2)
 |  >>> f = interpolate.interp2d(x, y, z, kind='cubic')
 |  
 |  Now use the obtained interpolation function and plot the result:
 |  
 |  >>> import matplotlib.pyplot as plt
 |  >>> xnew = np.arange(-5.01, 5.01, 1e-2)
 |  >>> ynew = np.arange(-5.01, 5.01, 1e-2)
 |  >>> znew = f(xnew, ynew)
 |  >>> plt.plot(x, z[0, :], 'ro-', xnew, znew[0, :], 'b-')
 |  >>> plt.show()
 |  
 |  Methods defined here:
 |  
 |  __call__(self, x, y, dx=0, dy=0, assume_sorted=False)
 |      Interpolate the function.
 |      
 |      Parameters
 |      ----------
 |      x : 1D array
 |          x-coordinates of the mesh on which to interpolate.
 |      y : 1D array
 |          y-coordinates of the mesh on which to interpolate.
 |      dx : int >= 0, < kx
 |          Order of partial derivatives in x.
 |      dy : int >= 0, < ky
 |          Order of partial derivatives in y.
 |      assume_sorted : bool, optional
 |          If False, values of `x` and `y` can be in any order and they are
 |          sorted first.
 |          If True, `x` and `y` have to be arrays of monotonically
 |          increasing values.
 |      
 |      Returns
 |      -------
 |      z : 2D array with shape (len(y), len(x))
 |          The interpolated values.
 |  
 |  __init__(self, x, y, z, kind='linear', copy=True, bounds_error=False, fill_value=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'x', 'y', 'z', 'kind', 'copy', 'bounds_error', 'fill_value')","(nan, nan, nan, nan, 'linear', True, False, None)","(nan, nan, nan, nan, 'str', 'bool', 'bool', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(self, x, y, z, kind='linear', copy=True, bounds_error=False, fill_value=None)"",)"
scipy,1.1.0,scipy.interpolate.interpolate.interpn,interpolate.interpolate,interpn,"Python Library Documentation: function interpn in module scipy.interpolate.interpolate

interpn(points, values, xi, method='linear', bounds_error=True, fill_value=nan)
    Multidimensional interpolation on regular grids.
    
    Parameters
    ----------
    points : tuple of ndarray of float, with shapes (m1, ), ..., (mn, )
        The points defining the regular grid in n dimensions.
    
    values : array_like, shape (m1, ..., mn, ...)
        The data on the regular grid in n dimensions.
    
    xi : ndarray of shape (..., ndim)
        The coordinates to sample the gridded data at
    
    method : str, optional
        The method of interpolation to perform. Supported are ""linear"" and
        ""nearest"", and ""splinef2d"". ""splinef2d"" is only supported for
        2-dimensional data.
    
    bounds_error : bool, optional
        If True, when interpolated values are requested outside of the
        domain of the input data, a ValueError is raised.
        If False, then `fill_value` is used.
    
    fill_value : number, optional
        If provided, the value to use for points outside of the
        interpolation domain. If None, values outside
        the domain are extrapolated.  Extrapolation is not supported by method
        ""splinef2d"".
    
    Returns
    -------
    values_x : ndarray, shape xi.shape[:-1] + values.shape[ndim:]
        Interpolated values at input coordinates.
    
    Notes
    -----
    
    .. versionadded:: 0.14
    
    See also
    --------
    NearestNDInterpolator : Nearest neighbour interpolation on unstructured
                            data in N dimensions
    
    LinearNDInterpolator : Piecewise linear interpolant on unstructured data
                           in N dimensions
    
    RegularGridInterpolator : Linear and nearest-neighbor Interpolation on a
                              regular grid in arbitrary dimensions
    
    RectBivariateSpline : Bivariate spline approximation over a rectangular mesh
",function,"(""(points, values, xi, method='linear', bounds_error=True, fill_value=nan)"",)",scipy,1.1.0,scipy.interpolate.interpolate.interpn,interpolate.interpolate,interpn,"Python Library Documentation: function interpn in module scipy.interpolate.interpolate

interpn(points, values, xi, method='linear', bounds_error=True, fill_value=nan)
    Multidimensional interpolation on regular grids.
    
    Parameters
    ----------
    points : tuple of ndarray of float, with shapes (m1, ), ..., (mn, )
        The points defining the regular grid in n dimensions.
    
    values : array_like, shape (m1, ..., mn, ...)
        The data on the regular grid in n dimensions.
    
    xi : ndarray of shape (..., ndim)
        The coordinates to sample the gridded data at
    
    method : str, optional
        The method of interpolation to perform. Supported are ""linear"" and
        ""nearest"", and ""splinef2d"". ""splinef2d"" is only supported for
        2-dimensional data.
    
    bounds_error : bool, optional
        If True, when interpolated values are requested outside of the
        domain of the input data, a ValueError is raised.
        If False, then `fill_value` is used.
    
    fill_value : number, optional
        If provided, the value to use for points outside of the
        interpolation domain. If None, values outside
        the domain are extrapolated.  Extrapolation is not supported by method
        ""splinef2d"".
    
    Returns
    -------
    values_x : ndarray, shape xi.shape[:-1] + values.shape[ndim:]
        Interpolated values at input coordinates.
    
    Notes
    -----
    
    .. versionadded:: 0.14
    
    See also
    --------
    NearestNDInterpolator : Nearest neighbour interpolation on unstructured
                            data in N dimensions
    
    LinearNDInterpolator : Piecewise linear interpolant on unstructured data
                           in N dimensions
    
    RegularGridInterpolator : Linear and nearest-neighbor Interpolation on a
                              regular grid in arbitrary dimensions
    
    RectBivariateSpline : Bivariate spline approximation over a rectangular mesh
",function,"('points', 'values', 'xi', 'method', 'bounds_error', 'fill_value')","(nan, nan, nan, 'linear', True, nan)","(nan, nan, nan, 'str', 'bool', nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(points, values, xi, method='linear', bounds_error=True, fill_value=nan)"",)"
scipy,1.1.0,scipy.interpolate.interpolate.intp,interpolate.interpolate,int64,"Python Library Documentation: class int64 in module numpy

class int64(signedinteger)
 |  64-bit integer. Character code 'l'. Python int compatible.
 |  
 |  Method resolution order:
 |      int64
 |      signedinteger
 |      integer
 |      number
 |      generic
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from integer:
 |  
 |  denominator
 |      denominator of value (1)
 |  
 |  numerator
 |      numerator of value (the value itself)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from generic:
 |  
 |  __array__(...)
 |      sc.__array__(|type) return 0-dim array
 |  
 |  __array_wrap__(...)
 |      sc.__array_wrap__(obj) return scalar from array
 |  
 |  __copy__(...)
 |  
 |  __deepcopy__(...)
 |  
 |  __format__(...)
 |      NumPy array scalar formatter
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __round__(...)
 |  
 |  __setstate__(...)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  all(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  any(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmax(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmin(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argsort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  astype(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  byteswap(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  choose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  clip(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  compress(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  conj(...)
 |  
 |  conjugate(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  copy(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumprod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumsum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  diagonal(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dump(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dumps(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  fill(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  flatten(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  getfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  item(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  itemset(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  max(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  mean(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  min(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  newbyteorder(...)
 |      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.
 |      
 |      The `new_order` code can be any from the following:
 |      
 |      * 'S' - swap dtype from current to opposite endian
 |      * {'<', 'L'} - little endian
 |      * {'>', 'B'} - big endian
 |      * {'=', 'N'} - native order
 |      * {'|', 'I'} - ignore (no change to byte order)
 |      
 |      Parameters
 |      ----------
 |      new_order : str, optional
 |          Byte order to force; a value from the byte order specifications
 |          above.  The default value ('S') results in swapping the current
 |          byte order. The code does a case-insensitive check on the first
 |          letter of `new_order` for the alternatives above.  For example,
 |          any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 |      
 |      
 |      Returns
 |      -------
 |      new_dtype : dtype
 |          New `dtype` object with the given change to the byte order.
 |  
 |  nonzero(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  prod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ptp(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  put(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ravel(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  repeat(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  reshape(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  resize(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  round(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  searchsorted(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setflags(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  squeeze(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  std(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  swapaxes(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  take(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tobytes(...)
 |  
 |  tofile(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tolist(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tostring(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  trace(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  transpose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  var(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  view(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from generic:
 |  
 |  T
 |      transpose
 |  
 |  __array_interface__
 |      Array protocol: Python side
 |  
 |  __array_priority__
 |      Array priority.
 |  
 |  __array_struct__
 |      Array protocol: struct
 |  
 |  base
 |      base object
 |  
 |  data
 |      pointer to start of data
 |  
 |  dtype
 |      get array data-descriptor
 |  
 |  flags
 |      integer value of flags
 |  
 |  flat
 |      a 1-d view of scalar
 |  
 |  imag
 |      imaginary part of scalar
 |  
 |  itemsize
 |      length of one element in bytes
 |  
 |  nbytes
 |      length of item in bytes
 |  
 |  ndim
 |      number of array dimensions
 |  
 |  real
 |      real part of scalar
 |  
 |  shape
 |      tuple of array dimensions
 |  
 |  size
 |      number of elements in the gentype
 |  
 |  strides
 |      tuple of bytes steps in each dimension
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.interpolate.interpolate.intp,interpolate.interpolate,int64,"Python Library Documentation: class int64 in module numpy

class int64(signedinteger)
 |  64-bit integer. Character code 'l'. Python int compatible.
 |  
 |  Method resolution order:
 |      int64
 |      signedinteger
 |      integer
 |      number
 |      generic
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from integer:
 |  
 |  denominator
 |      denominator of value (1)
 |  
 |  numerator
 |      numerator of value (the value itself)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from generic:
 |  
 |  __array__(...)
 |      sc.__array__(|type) return 0-dim array
 |  
 |  __array_wrap__(...)
 |      sc.__array_wrap__(obj) return scalar from array
 |  
 |  __copy__(...)
 |  
 |  __deepcopy__(...)
 |  
 |  __format__(...)
 |      NumPy array scalar formatter
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __round__(...)
 |  
 |  __setstate__(...)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  all(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  any(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmax(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmin(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argsort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  astype(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  byteswap(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  choose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  clip(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  compress(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  conj(...)
 |  
 |  conjugate(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  copy(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumprod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumsum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  diagonal(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dump(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dumps(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  fill(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  flatten(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  getfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  item(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  itemset(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  max(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  mean(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  min(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  newbyteorder(...)
 |      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.
 |      
 |      The `new_order` code can be any from the following:
 |      
 |      * 'S' - swap dtype from current to opposite endian
 |      * {'<', 'L'} - little endian
 |      * {'>', 'B'} - big endian
 |      * {'=', 'N'} - native order
 |      * {'|', 'I'} - ignore (no change to byte order)
 |      
 |      Parameters
 |      ----------
 |      new_order : str, optional
 |          Byte order to force; a value from the byte order specifications
 |          above.  The default value ('S') results in swapping the current
 |          byte order. The code does a case-insensitive check on the first
 |          letter of `new_order` for the alternatives above.  For example,
 |          any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 |      
 |      
 |      Returns
 |      -------
 |      new_dtype : dtype
 |          New `dtype` object with the given change to the byte order.
 |  
 |  nonzero(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  prod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ptp(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  put(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ravel(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  repeat(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  reshape(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  resize(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  round(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  searchsorted(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setflags(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  squeeze(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  std(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  swapaxes(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  take(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tobytes(...)
 |  
 |  tofile(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tolist(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tostring(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  trace(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  transpose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  var(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  view(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from generic:
 |  
 |  T
 |      transpose
 |  
 |  __array_interface__
 |      Array protocol: Python side
 |  
 |  __array_priority__
 |      Array priority.
 |  
 |  __array_struct__
 |      Array protocol: struct
 |  
 |  base
 |      base object
 |  
 |  data
 |      pointer to start of data
 |  
 |  dtype
 |      get array data-descriptor
 |  
 |  flags
 |      integer value of flags
 |  
 |  flat
 |      a 1-d view of scalar
 |  
 |  imag
 |      imaginary part of scalar
 |  
 |  itemsize
 |      length of one element in bytes
 |  
 |  nbytes
 |      length of item in bytes
 |  
 |  ndim
 |      number of array dimensions
 |  
 |  real
 |      real part of scalar
 |  
 |  shape
 |      tuple of array dimensions
 |  
 |  size
 |      number of elements in the gentype
 |  
 |  strides
 |      tuple of bytes steps in each dimension
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.interpolate.interpolate.lagrange,interpolate.interpolate,lagrange,"Python Library Documentation: function lagrange in module scipy.interpolate.interpolate

lagrange(x, w)
    Return a Lagrange interpolating polynomial.
    
    Given two 1-D arrays `x` and `w,` returns the Lagrange interpolating
    polynomial through the points ``(x, w)``.
    
    Warning: This implementation is numerically unstable. Do not expect to
    be able to use more than about 20 points even if they are chosen optimally.
    
    Parameters
    ----------
    x : array_like
        `x` represents the x-coordinates of a set of datapoints.
    w : array_like
        `w` represents the y-coordinates of a set of datapoints, i.e. f(`x`).
    
    Returns
    -------
    lagrange : `numpy.poly1d` instance
        The Lagrange interpolating polynomial.
    
    Examples
    --------
    Interpolate :math:`f(x) = x^3` by 3 points.
    
    >>> from scipy.interpolate import lagrange
    >>> x = np.array([0, 1, 2])
    >>> y = x**3
    >>> poly = lagrange(x, y)
    
    Since there are only 3 points, Lagrange polynomial has degree 2. Explicitly,
    it is given by
    
    .. math::
    
        \begin{aligned}
            L(x) &= 1\times \frac{x (x - 2)}{-1} + 8\times \frac{x (x-1)}{2} \\
                 &= x (-2 + 3x)
        \end{aligned}
    
    >>> from numpy.polynomial.polynomial import Polynomial
    >>> Polynomial(poly).coef
    array([ 3., -2.,  0.])
",function,"('(x, w)',)",scipy,1.1.0,scipy.interpolate.interpolate.lagrange,interpolate.interpolate,lagrange,"Python Library Documentation: function lagrange in module scipy.interpolate.interpolate

lagrange(x, w)
    Return a Lagrange interpolating polynomial.
    
    Given two 1-D arrays `x` and `w,` returns the Lagrange interpolating
    polynomial through the points ``(x, w)``.
    
    Warning: This implementation is numerically unstable. Do not expect to
    be able to use more than about 20 points even if they are chosen optimally.
    
    Parameters
    ----------
    x : array_like
        `x` represents the x-coordinates of a set of datapoints.
    w : array_like
        `w` represents the y-coordinates of a set of datapoints, i.e. f(`x`).
    
    Returns
    -------
    lagrange : `numpy.poly1d` instance
        The Lagrange interpolating polynomial.
    
    Examples
    --------
    Interpolate :math:`f(x) = x^3` by 3 points.
    
    >>> from scipy.interpolate import lagrange
    >>> x = np.array([0, 1, 2])
    >>> y = x**3
    >>> poly = lagrange(x, y)
    
    Since there are only 3 points, Lagrange polynomial has degree 2. Explicitly,
    it is given by
    
    .. math::
    
        \begin{aligned}
            L(x) &= 1\times \frac{x (x - 2)}{-1} + 8\times \frac{x (x-1)}{2} \\
                 &= x (-2 + 3x)
        \end{aligned}
    
    >>> from numpy.polynomial.polynomial import Polynomial
    >>> Polynomial(poly).coef
    array([ 3., -2.,  0.])
",function,"('x', 'w')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(x, w)',)"
scipy,1.1.0,scipy.interpolate.interpolate.make_interp_spline,interpolate.interpolate,make_interp_spline,"Python Library Documentation: function make_interp_spline in module scipy.interpolate._bsplines

make_interp_spline(x, y, k=3, t=None, bc_type=None, axis=0, check_finite=True)
    Compute the (coefficients of) interpolating B-spline.
    
    Parameters
    ----------
    x : array_like, shape (n,)
        Abscissas.
    y : array_like, shape (n, ...)
        Ordinates.
    k : int, optional
        B-spline degree. Default is cubic, k=3.
    t : array_like, shape (nt + k + 1,), optional.
        Knots.
        The number of knots needs to agree with the number of datapoints and
        the number of derivatives at the edges. Specifically, ``nt - n`` must
        equal ``len(deriv_l) + len(deriv_r)``.
    bc_type : 2-tuple or None
        Boundary conditions.
        Default is None, which means choosing the boundary conditions
        automatically. Otherwise, it must be a length-two tuple where the first
        element sets the boundary conditions at ``x[0]`` and the second
        element sets the boundary conditions at ``x[-1]``. Each of these must
        be an iterable of pairs ``(order, value)`` which gives the values of
        derivatives of specified orders at the given edge of the interpolation
        interval.
        Alternatively, the following string aliases are recognized:
    
        * ``""clamped""``: The first derivatives at the ends are zero. This is
           equivalent to ``bc_type=((1, 0.0), (1, 0.0))``.
        * ``""natural""``: The second derivatives at ends are zero. This is
          equivalent to ``bc_type=((2, 0.0), (2, 0.0))``.
        * ``""not-a-knot""`` (default): The first and second segments are the same
          polynomial. This is equivalent to having ``bc_type=None``.
    
    axis : int, optional
        Interpolation axis. Default is 0.
    check_finite : bool, optional
        Whether to check that the input arrays contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default is True.
    
    Returns
    -------
    b : a BSpline object of the degree ``k`` and with knots ``t``.
    
    Examples
    --------
    
    Use cubic interpolation on Chebyshev nodes:
    
    >>> def cheb_nodes(N):
    ...     jj = 2.*np.arange(N) + 1
    ...     x = np.cos(np.pi * jj / 2 / N)[::-1]
    ...     return x
    
    >>> x = cheb_nodes(20)
    >>> y = np.sqrt(1 - x**2)
    
    >>> from scipy.interpolate import BSpline, make_interp_spline
    >>> b = make_interp_spline(x, y)
    >>> np.allclose(b(x), y)
    True
    
    Note that the default is a cubic spline with a not-a-knot boundary condition
    
    >>> b.k
    3
    
    Here we use a 'natural' spline, with zero 2nd derivatives at edges:
    
    >>> l, r = [(2, 0.0)], [(2, 0.0)]
    >>> b_n = make_interp_spline(x, y, bc_type=(l, r))  # or, bc_type=""natural""
    >>> np.allclose(b_n(x), y)
    True
    >>> x0, x1 = x[0], x[-1]
    >>> np.allclose([b_n(x0, 2), b_n(x1, 2)], [0, 0])
    True
    
    Interpolation of parametric curves is also supported. As an example, we
    compute a discretization of a snail curve in polar coordinates
    
    >>> phi = np.linspace(0, 2.*np.pi, 40)
    >>> r = 0.3 + np.cos(phi)
    >>> x, y = r*np.cos(phi), r*np.sin(phi)  # convert to Cartesian coordinates
    
    Build an interpolating curve, parameterizing it by the angle
    
    >>> from scipy.interpolate import make_interp_spline
    >>> spl = make_interp_spline(phi, np.c_[x, y])
    
    Evaluate the interpolant on a finer grid (note that we transpose the result
    to unpack it into a pair of x- and y-arrays)
    
    >>> phi_new = np.linspace(0, 2.*np.pi, 100)
    >>> x_new, y_new = spl(phi_new).T
    
    Plot the result
    
    >>> import matplotlib.pyplot as plt
    >>> plt.plot(x, y, 'o')
    >>> plt.plot(x_new, y_new, '-')
    >>> plt.show()
    
    See Also
    --------
    BSpline : base class representing the B-spline objects
    CubicSpline : a cubic spline in the polynomial basis
    make_lsq_spline : a similar factory function for spline fitting
    UnivariateSpline : a wrapper over FITPACK spline fitting routines
    splrep : a wrapper over FITPACK spline fitting routines
",function,"('(x, y, k=3, t=None, bc_type=None, axis=0, check_finite=True)',)",scipy,1.1.0,scipy.interpolate.interpolate.make_interp_spline,interpolate.interpolate,make_interp_spline,"Python Library Documentation: function make_interp_spline in module scipy.interpolate._bsplines

make_interp_spline(x, y, k=3, t=None, bc_type=None, axis=0, check_finite=True)
    Compute the (coefficients of) interpolating B-spline.
    
    Parameters
    ----------
    x : array_like, shape (n,)
        Abscissas.
    y : array_like, shape (n, ...)
        Ordinates.
    k : int, optional
        B-spline degree. Default is cubic, k=3.
    t : array_like, shape (nt + k + 1,), optional.
        Knots.
        The number of knots needs to agree with the number of datapoints and
        the number of derivatives at the edges. Specifically, ``nt - n`` must
        equal ``len(deriv_l) + len(deriv_r)``.
    bc_type : 2-tuple or None
        Boundary conditions.
        Default is None, which means choosing the boundary conditions
        automatically. Otherwise, it must be a length-two tuple where the first
        element sets the boundary conditions at ``x[0]`` and the second
        element sets the boundary conditions at ``x[-1]``. Each of these must
        be an iterable of pairs ``(order, value)`` which gives the values of
        derivatives of specified orders at the given edge of the interpolation
        interval.
        Alternatively, the following string aliases are recognized:
    
        * ``""clamped""``: The first derivatives at the ends are zero. This is
           equivalent to ``bc_type=((1, 0.0), (1, 0.0))``.
        * ``""natural""``: The second derivatives at ends are zero. This is
          equivalent to ``bc_type=((2, 0.0), (2, 0.0))``.
        * ``""not-a-knot""`` (default): The first and second segments are the same
          polynomial. This is equivalent to having ``bc_type=None``.
    
    axis : int, optional
        Interpolation axis. Default is 0.
    check_finite : bool, optional
        Whether to check that the input arrays contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default is True.
    
    Returns
    -------
    b : a BSpline object of the degree ``k`` and with knots ``t``.
    
    Examples
    --------
    
    Use cubic interpolation on Chebyshev nodes:
    
    >>> def cheb_nodes(N):
    ...     jj = 2.*np.arange(N) + 1
    ...     x = np.cos(np.pi * jj / 2 / N)[::-1]
    ...     return x
    
    >>> x = cheb_nodes(20)
    >>> y = np.sqrt(1 - x**2)
    
    >>> from scipy.interpolate import BSpline, make_interp_spline
    >>> b = make_interp_spline(x, y)
    >>> np.allclose(b(x), y)
    True
    
    Note that the default is a cubic spline with a not-a-knot boundary condition
    
    >>> b.k
    3
    
    Here we use a 'natural' spline, with zero 2nd derivatives at edges:
    
    >>> l, r = [(2, 0.0)], [(2, 0.0)]
    >>> b_n = make_interp_spline(x, y, bc_type=(l, r))  # or, bc_type=""natural""
    >>> np.allclose(b_n(x), y)
    True
    >>> x0, x1 = x[0], x[-1]
    >>> np.allclose([b_n(x0, 2), b_n(x1, 2)], [0, 0])
    True
    
    Interpolation of parametric curves is also supported. As an example, we
    compute a discretization of a snail curve in polar coordinates
    
    >>> phi = np.linspace(0, 2.*np.pi, 40)
    >>> r = 0.3 + np.cos(phi)
    >>> x, y = r*np.cos(phi), r*np.sin(phi)  # convert to Cartesian coordinates
    
    Build an interpolating curve, parameterizing it by the angle
    
    >>> from scipy.interpolate import make_interp_spline
    >>> spl = make_interp_spline(phi, np.c_[x, y])
    
    Evaluate the interpolant on a finer grid (note that we transpose the result
    to unpack it into a pair of x- and y-arrays)
    
    >>> phi_new = np.linspace(0, 2.*np.pi, 100)
    >>> x_new, y_new = spl(phi_new).T
    
    Plot the result
    
    >>> import matplotlib.pyplot as plt
    >>> plt.plot(x, y, 'o')
    >>> plt.plot(x_new, y_new, '-')
    >>> plt.show()
    
    See Also
    --------
    BSpline : base class representing the B-spline objects
    CubicSpline : a cubic spline in the polynomial basis
    make_lsq_spline : a similar factory function for spline fitting
    UnivariateSpline : a wrapper over FITPACK spline fitting routines
    splrep : a wrapper over FITPACK spline fitting routines
",function,"('x', 'y', 'k', 't', 'bc_type', 'axis', 'check_finite')","(nan, nan, 3, None, None, 0, True)","(nan, nan, 'int', 'NoneType', 'NoneType', 'int', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, y, k=3, t=None, bc_type=None, axis=0, check_finite=True)',)"
scipy,1.1.0,scipy.interpolate.interpolate.poly1d,interpolate.interpolate,poly1d,"Python Library Documentation: class poly1d in module numpy.lib.polynomial

class poly1d(builtins.object)
 |  A one-dimensional polynomial class.
 |  
 |  A convenience class, used to encapsulate ""natural"" operations on
 |  polynomials so that said operations may take on their customary
 |  form in code (see Examples).
 |  
 |  Parameters
 |  ----------
 |  c_or_r : array_like
 |      The polynomial's coefficients, in decreasing powers, or if
 |      the value of the second parameter is True, the polynomial's
 |      roots (values where the polynomial evaluates to 0).  For example,
 |      ``poly1d([1, 2, 3])`` returns an object that represents
 |      :math:`x^2 + 2x + 3`, whereas ``poly1d([1, 2, 3], True)`` returns
 |      one that represents :math:`(x-1)(x-2)(x-3) = x^3 - 6x^2 + 11x -6`.
 |  r : bool, optional
 |      If True, `c_or_r` specifies the polynomial's roots; the default
 |      is False.
 |  variable : str, optional
 |      Changes the variable used when printing `p` from `x` to `variable`
 |      (see Examples).
 |  
 |  Examples
 |  --------
 |  Construct the polynomial :math:`x^2 + 2x + 3`:
 |  
 |  >>> p = np.poly1d([1, 2, 3])
 |  >>> print(np.poly1d(p))
 |     2
 |  1 x + 2 x + 3
 |  
 |  Evaluate the polynomial at :math:`x = 0.5`:
 |  
 |  >>> p(0.5)
 |  4.25
 |  
 |  Find the roots:
 |  
 |  >>> p.r
 |  array([-1.+1.41421356j, -1.-1.41421356j])
 |  >>> p(p.r)
 |  array([ -4.44089210e-16+0.j,  -4.44089210e-16+0.j])
 |  
 |  These numbers in the previous line represent (0, 0) to machine precision
 |  
 |  Show the coefficients:
 |  
 |  >>> p.c
 |  array([1, 2, 3])
 |  
 |  Display the order (the leading zero-coefficients are removed):
 |  
 |  >>> p.order
 |  2
 |  
 |  Show the coefficient of the k-th power in the polynomial
 |  (which is equivalent to ``p.c[-(i+1)]``):
 |  
 |  >>> p[1]
 |  2
 |  
 |  Polynomials can be added, subtracted, multiplied, and divided
 |  (returns quotient and remainder):
 |  
 |  >>> p * p
 |  poly1d([ 1,  4, 10, 12,  9])
 |  
 |  >>> (p**3 + 4) / p
 |  (poly1d([  1.,   4.,  10.,  12.,   9.]), poly1d([ 4.]))
 |  
 |  ``asarray(p)`` gives the coefficient array, so polynomials can be
 |  used in all functions that accept arrays:
 |  
 |  >>> p**2 # square of polynomial
 |  poly1d([ 1,  4, 10, 12,  9])
 |  
 |  >>> np.square(p) # square of individual coefficients
 |  array([1, 4, 9])
 |  
 |  The variable used in the string representation of `p` can be modified,
 |  using the `variable` parameter:
 |  
 |  >>> p = np.poly1d([1,2,3], variable='z')
 |  >>> print(p)
 |     2
 |  1 z + 2 z + 3
 |  
 |  Construct a polynomial from its roots:
 |  
 |  >>> np.poly1d([1, 2], True)
 |  poly1d([ 1, -3,  2])
 |  
 |  This is the same polynomial as obtained by:
 |  
 |  >>> np.poly1d([1, -1]) * np.poly1d([1, -2])
 |  poly1d([ 1, -3,  2])
 |  
 |  Methods defined here:
 |  
 |  __add__(self, other)
 |  
 |  __array__(self, t=None)
 |  
 |  __call__(self, val)
 |      Call self as a function.
 |  
 |  __div__(self, other)
 |  
 |  __eq__(self, other)
 |      Return self==value.
 |  
 |  __getitem__(self, val)
 |  
 |  __init__(self, c_or_r, r=False, variable=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self)
 |  
 |  __len__(self)
 |  
 |  __mul__(self, other)
 |  
 |  __ne__(self, other)
 |      Return self!=value.
 |  
 |  __neg__(self)
 |  
 |  __pos__(self)
 |  
 |  __pow__(self, val)
 |  
 |  __radd__(self, other)
 |  
 |  __rdiv__(self, other)
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __rmul__(self, other)
 |  
 |  __rsub__(self, other)
 |  
 |  __rtruediv__ = __rdiv__(self, other)
 |  
 |  __setitem__(self, key, val)
 |  
 |  __str__(self)
 |      Return str(self).
 |  
 |  __sub__(self, other)
 |  
 |  __truediv__ = __div__(self, other)
 |  
 |  deriv(self, m=1)
 |      Return a derivative of this polynomial.
 |      
 |      Refer to `polyder` for full documentation.
 |      
 |      See Also
 |      --------
 |      polyder : equivalent function
 |  
 |  integ(self, m=1, k=0)
 |      Return an antiderivative (indefinite integral) of this polynomial.
 |      
 |      Refer to `polyint` for full documentation.
 |      
 |      See Also
 |      --------
 |      polyint : equivalent function
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  c
 |      A copy of the polynomial coefficients
 |  
 |  coef
 |      A copy of the polynomial coefficients
 |  
 |  coefficients
 |      A copy of the polynomial coefficients
 |  
 |  coeffs
 |      A copy of the polynomial coefficients
 |  
 |  o
 |      The order or degree of the polynomial
 |  
 |  order
 |      The order or degree of the polynomial
 |  
 |  r
 |      The roots of the polynomial, where self(x) == 0
 |  
 |  roots
 |      The roots of the polynomial, where self(x) == 0
 |  
 |  variable
 |      The name of the polynomial variable
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None
",class,"('(self, c_or_r, r=False, variable=None)',)",scipy,1.1.0,scipy.interpolate.interpolate.poly1d,interpolate.interpolate,poly1d,"Python Library Documentation: class poly1d in module numpy.lib.polynomial

class poly1d(builtins.object)
 |  A one-dimensional polynomial class.
 |  
 |  A convenience class, used to encapsulate ""natural"" operations on
 |  polynomials so that said operations may take on their customary
 |  form in code (see Examples).
 |  
 |  Parameters
 |  ----------
 |  c_or_r : array_like
 |      The polynomial's coefficients, in decreasing powers, or if
 |      the value of the second parameter is True, the polynomial's
 |      roots (values where the polynomial evaluates to 0).  For example,
 |      ``poly1d([1, 2, 3])`` returns an object that represents
 |      :math:`x^2 + 2x + 3`, whereas ``poly1d([1, 2, 3], True)`` returns
 |      one that represents :math:`(x-1)(x-2)(x-3) = x^3 - 6x^2 + 11x -6`.
 |  r : bool, optional
 |      If True, `c_or_r` specifies the polynomial's roots; the default
 |      is False.
 |  variable : str, optional
 |      Changes the variable used when printing `p` from `x` to `variable`
 |      (see Examples).
 |  
 |  Examples
 |  --------
 |  Construct the polynomial :math:`x^2 + 2x + 3`:
 |  
 |  >>> p = np.poly1d([1, 2, 3])
 |  >>> print(np.poly1d(p))
 |     2
 |  1 x + 2 x + 3
 |  
 |  Evaluate the polynomial at :math:`x = 0.5`:
 |  
 |  >>> p(0.5)
 |  4.25
 |  
 |  Find the roots:
 |  
 |  >>> p.r
 |  array([-1.+1.41421356j, -1.-1.41421356j])
 |  >>> p(p.r)
 |  array([ -4.44089210e-16+0.j,  -4.44089210e-16+0.j])
 |  
 |  These numbers in the previous line represent (0, 0) to machine precision
 |  
 |  Show the coefficients:
 |  
 |  >>> p.c
 |  array([1, 2, 3])
 |  
 |  Display the order (the leading zero-coefficients are removed):
 |  
 |  >>> p.order
 |  2
 |  
 |  Show the coefficient of the k-th power in the polynomial
 |  (which is equivalent to ``p.c[-(i+1)]``):
 |  
 |  >>> p[1]
 |  2
 |  
 |  Polynomials can be added, subtracted, multiplied, and divided
 |  (returns quotient and remainder):
 |  
 |  >>> p * p
 |  poly1d([ 1,  4, 10, 12,  9])
 |  
 |  >>> (p**3 + 4) / p
 |  (poly1d([  1.,   4.,  10.,  12.,   9.]), poly1d([ 4.]))
 |  
 |  ``asarray(p)`` gives the coefficient array, so polynomials can be
 |  used in all functions that accept arrays:
 |  
 |  >>> p**2 # square of polynomial
 |  poly1d([ 1,  4, 10, 12,  9])
 |  
 |  >>> np.square(p) # square of individual coefficients
 |  array([1, 4, 9])
 |  
 |  The variable used in the string representation of `p` can be modified,
 |  using the `variable` parameter:
 |  
 |  >>> p = np.poly1d([1,2,3], variable='z')
 |  >>> print(p)
 |     2
 |  1 z + 2 z + 3
 |  
 |  Construct a polynomial from its roots:
 |  
 |  >>> np.poly1d([1, 2], True)
 |  poly1d([ 1, -3,  2])
 |  
 |  This is the same polynomial as obtained by:
 |  
 |  >>> np.poly1d([1, -1]) * np.poly1d([1, -2])
 |  poly1d([ 1, -3,  2])
 |  
 |  Methods defined here:
 |  
 |  __add__(self, other)
 |  
 |  __array__(self, t=None)
 |  
 |  __call__(self, val)
 |      Call self as a function.
 |  
 |  __div__(self, other)
 |  
 |  __eq__(self, other)
 |      Return self==value.
 |  
 |  __getitem__(self, val)
 |  
 |  __init__(self, c_or_r, r=False, variable=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self)
 |  
 |  __len__(self)
 |  
 |  __mul__(self, other)
 |  
 |  __ne__(self, other)
 |      Return self!=value.
 |  
 |  __neg__(self)
 |  
 |  __pos__(self)
 |  
 |  __pow__(self, val)
 |  
 |  __radd__(self, other)
 |  
 |  __rdiv__(self, other)
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __rmul__(self, other)
 |  
 |  __rsub__(self, other)
 |  
 |  __rtruediv__ = __rdiv__(self, other)
 |  
 |  __setitem__(self, key, val)
 |  
 |  __str__(self)
 |      Return str(self).
 |  
 |  __sub__(self, other)
 |  
 |  __truediv__ = __div__(self, other)
 |  
 |  deriv(self, m=1)
 |      Return a derivative of this polynomial.
 |      
 |      Refer to `polyder` for full documentation.
 |      
 |      See Also
 |      --------
 |      polyder : equivalent function
 |  
 |  integ(self, m=1, k=0)
 |      Return an antiderivative (indefinite integral) of this polynomial.
 |      
 |      Refer to `polyint` for full documentation.
 |      
 |      See Also
 |      --------
 |      polyint : equivalent function
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  c
 |      A copy of the polynomial coefficients
 |  
 |  coef
 |      A copy of the polynomial coefficients
 |  
 |  coefficients
 |      A copy of the polynomial coefficients
 |  
 |  coeffs
 |      A copy of the polynomial coefficients
 |  
 |  o
 |      The order or degree of the polynomial
 |  
 |  order
 |      The order or degree of the polynomial
 |  
 |  r
 |      The roots of the polynomial, where self(x) == 0
 |  
 |  roots
 |      The roots of the polynomial, where self(x) == 0
 |  
 |  variable
 |      The name of the polynomial variable
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None
",class,"('self', 'c_or_r', 'r', 'variable')","(nan, nan, False, None)","(nan, nan, 'bool', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, c_or_r, r=False, variable=None)',)"
scipy,1.1.0,scipy.interpolate.interpolate.prod,interpolate.interpolate,prod,"Python Library Documentation: function prod in module scipy.interpolate.interpolate

prod(x)
    Product of a list of numbers; ~40x faster vs np.prod for Python tuples
",function,"('(x)',)",scipy,1.1.0,scipy.interpolate.interpolate.prod,interpolate.interpolate,prod,"Python Library Documentation: function prod in module scipy.interpolate.interpolate

prod(x)
    Product of a list of numbers; ~40x faster vs np.prod for Python tuples
",function,"('x',)","(nan,)","(nan,)","('arg_info',)","('(x)',)"
scipy,1.1.0,scipy.interpolate.interpolate.ravel,interpolate.interpolate,ravel,"Python Library Documentation: function ravel in module numpy.core.fromnumeric

ravel(a, order='C')
    Return a contiguous flattened array.
    
    A 1-D array, containing the elements of the input, is returned.  A copy is
    made only if needed.
    
    As of NumPy 1.10, the returned array will have the same type as the input
    array. (for example, a masked array will be returned for a masked array
    input)
    
    Parameters
    ----------
    a : array_like
        Input array.  The elements in `a` are read in the order specified by
        `order`, and packed as a 1-D array.
    order : {'C','F', 'A', 'K'}, optional
    
        The elements of `a` are read using this index order. 'C' means
        to index the elements in row-major, C-style order,
        with the last axis index changing fastest, back to the first
        axis index changing slowest.  'F' means to index the elements
        in column-major, Fortran-style order, with the
        first index changing fastest, and the last index changing
        slowest. Note that the 'C' and 'F' options take no account of
        the memory layout of the underlying array, and only refer to
        the order of axis indexing.  'A' means to read the elements in
        Fortran-like index order if `a` is Fortran *contiguous* in
        memory, C-like order otherwise.  'K' means to read the
        elements in the order they occur in memory, except for
        reversing the data when strides are negative.  By default, 'C'
        index order is used.
    
    Returns
    -------
    y : array_like
        If `a` is a matrix, y is a 1-D ndarray, otherwise y is an array of
        the same subtype as `a`. The shape of the returned array is
        ``(a.size,)``. Matrices are special cased for backward
        compatibility.
    
    See Also
    --------
    ndarray.flat : 1-D iterator over an array.
    ndarray.flatten : 1-D array copy of the elements of an array
                      in row-major order.
    ndarray.reshape : Change the shape of an array without changing its data.
    
    Notes
    -----
    In row-major, C-style order, in two dimensions, the row index
    varies the slowest, and the column index the quickest.  This can
    be generalized to multiple dimensions, where row-major order
    implies that the index along the first axis varies slowest, and
    the index along the last quickest.  The opposite holds for
    column-major, Fortran-style index ordering.
    
    When a view is desired in as many cases as possible, ``arr.reshape(-1)``
    may be preferable.
    
    Examples
    --------
    It is equivalent to ``reshape(-1, order=order)``.
    
    >>> x = np.array([[1, 2, 3], [4, 5, 6]])
    >>> print(np.ravel(x))
    [1 2 3 4 5 6]
    
    >>> print(x.reshape(-1))
    [1 2 3 4 5 6]
    
    >>> print(np.ravel(x, order='F'))
    [1 4 2 5 3 6]
    
    When ``order`` is 'A', it will preserve the array's 'C' or 'F' ordering:
    
    >>> print(np.ravel(x.T))
    [1 4 2 5 3 6]
    >>> print(np.ravel(x.T, order='A'))
    [1 2 3 4 5 6]
    
    When ``order`` is 'K', it will preserve orderings that are neither 'C'
    nor 'F', but won't reverse axes:
    
    >>> a = np.arange(3)[::-1]; a
    array([2, 1, 0])
    >>> a.ravel(order='C')
    array([2, 1, 0])
    >>> a.ravel(order='K')
    array([2, 1, 0])
    
    >>> a = np.arange(12).reshape(2,3,2).swapaxes(1,2); a
    array([[[ 0,  2,  4],
            [ 1,  3,  5]],
           [[ 6,  8, 10],
            [ 7,  9, 11]]])
    >>> a.ravel(order='C')
    array([ 0,  2,  4,  1,  3,  5,  6,  8, 10,  7,  9, 11])
    >>> a.ravel(order='K')
    array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
",function,"(""(a, order='C')"",)",scipy,1.1.0,scipy.interpolate.interpolate.ravel,interpolate.interpolate,ravel,"Python Library Documentation: function ravel in module numpy.core.fromnumeric

ravel(a, order='C')
    Return a contiguous flattened array.
    
    A 1-D array, containing the elements of the input, is returned.  A copy is
    made only if needed.
    
    As of NumPy 1.10, the returned array will have the same type as the input
    array. (for example, a masked array will be returned for a masked array
    input)
    
    Parameters
    ----------
    a : array_like
        Input array.  The elements in `a` are read in the order specified by
        `order`, and packed as a 1-D array.
    order : {'C','F', 'A', 'K'}, optional
    
        The elements of `a` are read using this index order. 'C' means
        to index the elements in row-major, C-style order,
        with the last axis index changing fastest, back to the first
        axis index changing slowest.  'F' means to index the elements
        in column-major, Fortran-style order, with the
        first index changing fastest, and the last index changing
        slowest. Note that the 'C' and 'F' options take no account of
        the memory layout of the underlying array, and only refer to
        the order of axis indexing.  'A' means to read the elements in
        Fortran-like index order if `a` is Fortran *contiguous* in
        memory, C-like order otherwise.  'K' means to read the
        elements in the order they occur in memory, except for
        reversing the data when strides are negative.  By default, 'C'
        index order is used.
    
    Returns
    -------
    y : array_like
        If `a` is a matrix, y is a 1-D ndarray, otherwise y is an array of
        the same subtype as `a`. The shape of the returned array is
        ``(a.size,)``. Matrices are special cased for backward
        compatibility.
    
    See Also
    --------
    ndarray.flat : 1-D iterator over an array.
    ndarray.flatten : 1-D array copy of the elements of an array
                      in row-major order.
    ndarray.reshape : Change the shape of an array without changing its data.
    
    Notes
    -----
    In row-major, C-style order, in two dimensions, the row index
    varies the slowest, and the column index the quickest.  This can
    be generalized to multiple dimensions, where row-major order
    implies that the index along the first axis varies slowest, and
    the index along the last quickest.  The opposite holds for
    column-major, Fortran-style index ordering.
    
    When a view is desired in as many cases as possible, ``arr.reshape(-1)``
    may be preferable.
    
    Examples
    --------
    It is equivalent to ``reshape(-1, order=order)``.
    
    >>> x = np.array([[1, 2, 3], [4, 5, 6]])
    >>> print(np.ravel(x))
    [1 2 3 4 5 6]
    
    >>> print(x.reshape(-1))
    [1 2 3 4 5 6]
    
    >>> print(np.ravel(x, order='F'))
    [1 4 2 5 3 6]
    
    When ``order`` is 'A', it will preserve the array's 'C' or 'F' ordering:
    
    >>> print(np.ravel(x.T))
    [1 4 2 5 3 6]
    >>> print(np.ravel(x.T, order='A'))
    [1 2 3 4 5 6]
    
    When ``order`` is 'K', it will preserve orderings that are neither 'C'
    nor 'F', but won't reverse axes:
    
    >>> a = np.arange(3)[::-1]; a
    array([2, 1, 0])
    >>> a.ravel(order='C')
    array([2, 1, 0])
    >>> a.ravel(order='K')
    array([2, 1, 0])
    
    >>> a = np.arange(12).reshape(2,3,2).swapaxes(1,2); a
    array([[[ 0,  2,  4],
            [ 1,  3,  5]],
           [[ 6,  8, 10],
            [ 7,  9, 11]]])
    >>> a.ravel(order='C')
    array([ 0,  2,  4,  1,  3,  5,  6,  8, 10,  7,  9, 11])
    >>> a.ravel(order='K')
    array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
",function,"('a', 'order')","(nan, 'C')","(nan, 'str')","('arg_info', 'arg_info')","(""(a, order='C')"",)"
scipy,1.1.0,scipy.interpolate.interpolate.searchsorted,interpolate.interpolate,searchsorted,"Python Library Documentation: function searchsorted in module numpy.core.fromnumeric

searchsorted(a, v, side='left', sorter=None)
    Find indices where elements should be inserted to maintain order.
    
    Find the indices into a sorted array `a` such that, if the
    corresponding elements in `v` were inserted before the indices, the
    order of `a` would be preserved.
    
    Parameters
    ----------
    a : 1-D array_like
        Input array. If `sorter` is None, then it must be sorted in
        ascending order, otherwise `sorter` must be an array of indices
        that sort it.
    v : array_like
        Values to insert into `a`.
    side : {'left', 'right'}, optional
        If 'left', the index of the first suitable location found is given.
        If 'right', return the last such index.  If there is no suitable
        index, return either 0 or N (where N is the length of `a`).
    sorter : 1-D array_like, optional
        Optional array of integer indices that sort array a into ascending
        order. They are typically the result of argsort.
    
        .. versionadded:: 1.7.0
    
    Returns
    -------
    indices : array of ints
        Array of insertion points with the same shape as `v`.
    
    See Also
    --------
    sort : Return a sorted copy of an array.
    histogram : Produce histogram from 1-D data.
    
    Notes
    -----
    Binary search is used to find the required insertion points.
    
    As of NumPy 1.4.0 `searchsorted` works with real/complex arrays containing
    `nan` values. The enhanced sort order is documented in `sort`.
    
    Examples
    --------
    >>> np.searchsorted([1,2,3,4,5], 3)
    2
    >>> np.searchsorted([1,2,3,4,5], 3, side='right')
    3
    >>> np.searchsorted([1,2,3,4,5], [-10, 10, 2, 3])
    array([0, 5, 1, 2])
",function,"(""(a, v, side='left', sorter=None)"",)",scipy,1.1.0,scipy.interpolate.interpolate.searchsorted,interpolate.interpolate,searchsorted,"Python Library Documentation: function searchsorted in module numpy.core.fromnumeric

searchsorted(a, v, side='left', sorter=None)
    Find indices where elements should be inserted to maintain order.
    
    Find the indices into a sorted array `a` such that, if the
    corresponding elements in `v` were inserted before the indices, the
    order of `a` would be preserved.
    
    Parameters
    ----------
    a : 1-D array_like
        Input array. If `sorter` is None, then it must be sorted in
        ascending order, otherwise `sorter` must be an array of indices
        that sort it.
    v : array_like
        Values to insert into `a`.
    side : {'left', 'right'}, optional
        If 'left', the index of the first suitable location found is given.
        If 'right', return the last such index.  If there is no suitable
        index, return either 0 or N (where N is the length of `a`).
    sorter : 1-D array_like, optional
        Optional array of integer indices that sort array a into ascending
        order. They are typically the result of argsort.
    
        .. versionadded:: 1.7.0
    
    Returns
    -------
    indices : array of ints
        Array of insertion points with the same shape as `v`.
    
    See Also
    --------
    sort : Return a sorted copy of an array.
    histogram : Produce histogram from 1-D data.
    
    Notes
    -----
    Binary search is used to find the required insertion points.
    
    As of NumPy 1.4.0 `searchsorted` works with real/complex arrays containing
    `nan` values. The enhanced sort order is documented in `sort`.
    
    Examples
    --------
    >>> np.searchsorted([1,2,3,4,5], 3)
    2
    >>> np.searchsorted([1,2,3,4,5], 3, side='right')
    3
    >>> np.searchsorted([1,2,3,4,5], [-10, 10, 2, 3])
    array([0, 5, 1, 2])
",function,"('a', 'v', 'side', 'sorter')","(nan, nan, 'left', None)","(nan, nan, 'str', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a, v, side='left', sorter=None)"",)"
scipy,1.1.0,scipy.interpolate.interpolate.spleval,interpolate.interpolate,spleval,"Python Library Documentation: function spleval in module numpy.lib.utils

spleval(*args, **kwds)
    `spleval` is deprecated!
    spleval is deprecated in scipy 0.19.0, use BSpline instead.
    
    
        Evaluate a fixed spline represented by the given tuple at the new x-values
    
        The `xj` values are the interior knot points.  The approximation
        region is `xj[0]` to `xj[-1]`.  If N+1 is the length of `xj`, then `cvals`
        should have length N+k where `k` is the order of the spline.
    
        Parameters
        ----------
        (xj, cvals, k) : tuple
            Parameters that define the fixed spline
        xj : array_like
            Interior knot points
        cvals : array_like
            Curvature
        k : int
            Order of the spline
        xnew : array_like
            Locations to calculate spline
        deriv : int
            Deriv
    
        Returns
        -------
        spleval : ndarray
            If `cvals` represents more than one curve (`cvals.ndim` > 1) and/or
            `xnew` is N-d, then the result is `xnew.shape` + `cvals.shape[1:]`
            providing the interpolation of multiple curves.
    
        Notes
        -----
        Internally, an additional `k`-1 knot points are added on either side of
        the spline.
",function,"('(*args, **kwds)',)",scipy,1.1.0,scipy.interpolate.interpolate.spleval,interpolate.interpolate,spleval,"Python Library Documentation: function spleval in module numpy.lib.utils

spleval(*args, **kwds)
    `spleval` is deprecated!
    spleval is deprecated in scipy 0.19.0, use BSpline instead.
    
    
        Evaluate a fixed spline represented by the given tuple at the new x-values
    
        The `xj` values are the interior knot points.  The approximation
        region is `xj[0]` to `xj[-1]`.  If N+1 is the length of `xj`, then `cvals`
        should have length N+k where `k` is the order of the spline.
    
        Parameters
        ----------
        (xj, cvals, k) : tuple
            Parameters that define the fixed spline
        xj : array_like
            Interior knot points
        cvals : array_like
            Curvature
        k : int
            Order of the spline
        xnew : array_like
            Locations to calculate spline
        deriv : int
            Deriv
    
        Returns
        -------
        spleval : ndarray
            If `cvals` represents more than one curve (`cvals.ndim` > 1) and/or
            `xnew` is N-d, then the result is `xnew.shape` + `cvals.shape[1:]`
            providing the interpolation of multiple curves.
    
        Notes
        -----
        Internally, an additional `k`-1 knot points are added on either side of
        the spline.
",function,(),(),(),(),"('(*args, **kwds)',)"
scipy,1.1.0,scipy.interpolate.interpolate.spline,interpolate.interpolate,spline,"Python Library Documentation: function spline in module numpy.lib.utils

spline(*args, **kwds)
    `spline` is deprecated!
    spline is deprecated in scipy 0.19.0, use Bspline class instead.
    
    
        Interpolate a curve at new points using a spline fit
    
        Parameters
        ----------
        xk, yk : array_like
            The x and y values that define the curve.
        xnew : array_like
            The x values where spline should estimate the y values.
        order : int
            Default is 3.
        kind : string
            One of {'smoothest'}
        conds : Don't know
            Don't know
    
        Returns
        -------
        spline : ndarray
            An array of y values; the spline evaluated at the positions `xnew`.
",function,"('(*args, **kwds)',)",scipy,1.1.0,scipy.interpolate.interpolate.spline,interpolate.interpolate,spline,"Python Library Documentation: function spline in module numpy.lib.utils

spline(*args, **kwds)
    `spline` is deprecated!
    spline is deprecated in scipy 0.19.0, use Bspline class instead.
    
    
        Interpolate a curve at new points using a spline fit
    
        Parameters
        ----------
        xk, yk : array_like
            The x and y values that define the curve.
        xnew : array_like
            The x values where spline should estimate the y values.
        order : int
            Default is 3.
        kind : string
            One of {'smoothest'}
        conds : Don't know
            Don't know
    
        Returns
        -------
        spline : ndarray
            An array of y values; the spline evaluated at the positions `xnew`.
",function,(),(),(),(),"('(*args, **kwds)',)"
scipy,1.1.0,scipy.interpolate.interpolate.splmake,interpolate.interpolate,splmake,"Python Library Documentation: function splmake in module numpy.lib.utils

splmake(*args, **kwds)
    `splmake` is deprecated!
    splmake is deprecated in scipy 0.19.0, use make_interp_spline instead.
    
    
        Return a representation of a spline given data-points at internal knots
    
        Parameters
        ----------
        xk : array_like
            The input array of x values of rank 1
        yk : array_like
            The input array of y values of rank N. `yk` can be an N-d array to
            represent more than one curve, through the same `xk` points. The first
            dimension is assumed to be the interpolating dimension and is the same
            length of `xk`.
        order : int, optional
            Order of the spline
        kind : str, optional
            Can be 'smoothest', 'not_a_knot', 'fixed', 'clamped', 'natural',
            'periodic', 'symmetric', 'user', 'mixed' and it is ignored if order < 2
        conds : optional
            Conds
    
        Returns
        -------
        splmake : tuple
            Return a (`xk`, `cvals`, `k`) representation of a spline given
            data-points where the (internal) knots are at the data-points.
",function,"('(*args, **kwds)',)",scipy,1.1.0,scipy.interpolate.interpolate.splmake,interpolate.interpolate,splmake,"Python Library Documentation: function splmake in module numpy.lib.utils

splmake(*args, **kwds)
    `splmake` is deprecated!
    splmake is deprecated in scipy 0.19.0, use make_interp_spline instead.
    
    
        Return a representation of a spline given data-points at internal knots
    
        Parameters
        ----------
        xk : array_like
            The input array of x values of rank 1
        yk : array_like
            The input array of y values of rank N. `yk` can be an N-d array to
            represent more than one curve, through the same `xk` points. The first
            dimension is assumed to be the interpolating dimension and is the same
            length of `xk`.
        order : int, optional
            Order of the spline
        kind : str, optional
            Can be 'smoothest', 'not_a_knot', 'fixed', 'clamped', 'natural',
            'periodic', 'symmetric', 'user', 'mixed' and it is ignored if order < 2
        conds : optional
            Conds
    
        Returns
        -------
        splmake : tuple
            Return a (`xk`, `cvals`, `k`) representation of a spline given
            data-points where the (internal) knots are at the data-points.
",function,(),(),(),(),"('(*args, **kwds)',)"
scipy,1.1.0,scipy.interpolate.interpolate.spltopp,interpolate.interpolate,spltopp,"Python Library Documentation: function spltopp in module numpy.lib.utils

spltopp(*args, **kwds)
    `spltopp` is deprecated!
    spltopp is deprecated in scipy 0.19.0, use PPoly.from_spline instead.
    
    Return a piece-wise polynomial object from a fixed-spline tuple.
",function,"('(*args, **kwds)',)",scipy,1.1.0,scipy.interpolate.interpolate.spltopp,interpolate.interpolate,spltopp,"Python Library Documentation: function spltopp in module numpy.lib.utils

spltopp(*args, **kwds)
    `spltopp` is deprecated!
    spltopp is deprecated in scipy 0.19.0, use PPoly.from_spline instead.
    
    Return a piece-wise polynomial object from a fixed-spline tuple.
",function,(),(),(),(),"('(*args, **kwds)',)"
scipy,1.1.0,scipy.interpolate.interpolate.transpose,interpolate.interpolate,transpose,"Python Library Documentation: function transpose in module numpy.core.fromnumeric

transpose(a, axes=None)
    Permute the dimensions of an array.
    
    Parameters
    ----------
    a : array_like
        Input array.
    axes : list of ints, optional
        By default, reverse the dimensions, otherwise permute the axes
        according to the values given.
    
    Returns
    -------
    p : ndarray
        `a` with its axes permuted.  A view is returned whenever
        possible.
    
    See Also
    --------
    moveaxis
    argsort
    
    Notes
    -----
    Use `transpose(a, argsort(axes))` to invert the transposition of tensors
    when using the `axes` keyword argument.
    
    Transposing a 1-D array returns an unchanged view of the original array.
    
    Examples
    --------
    >>> x = np.arange(4).reshape((2,2))
    >>> x
    array([[0, 1],
           [2, 3]])
    
    >>> np.transpose(x)
    array([[0, 2],
           [1, 3]])
    
    >>> x = np.ones((1, 2, 3))
    >>> np.transpose(x, (1, 0, 2)).shape
    (2, 1, 3)
",function,"('(a, axes=None)',)",scipy,1.1.0,scipy.interpolate.interpolate.transpose,interpolate.interpolate,transpose,"Python Library Documentation: function transpose in module numpy.core.fromnumeric

transpose(a, axes=None)
    Permute the dimensions of an array.
    
    Parameters
    ----------
    a : array_like
        Input array.
    axes : list of ints, optional
        By default, reverse the dimensions, otherwise permute the axes
        according to the values given.
    
    Returns
    -------
    p : ndarray
        `a` with its axes permuted.  A view is returned whenever
        possible.
    
    See Also
    --------
    moveaxis
    argsort
    
    Notes
    -----
    Use `transpose(a, argsort(axes))` to invert the transposition of tensors
    when using the `axes` keyword argument.
    
    Transposing a 1-D array returns an unchanged view of the original array.
    
    Examples
    --------
    >>> x = np.arange(4).reshape((2,2))
    >>> x
    array([[0, 1],
           [2, 3]])
    
    >>> np.transpose(x)
    array([[0, 2],
           [1, 3]])
    
    >>> x = np.ones((1, 2, 3))
    >>> np.transpose(x, (1, 0, 2)).shape
    (2, 1, 3)
",function,"('a', 'axes')","(nan, None)","(nan, 'NoneType')","('arg_info', 'arg_info')","('(a, axes=None)',)"
scipy,1.1.0,scipy.interpolate.interpolate.xrange,interpolate.interpolate,range,"Python Library Documentation: class range in module builtins

class range(object)
 |  range(stop) -> range object
 |  range(start, stop[, step]) -> range object
 |  
 |  Return an object that produces a sequence of integers from start (inclusive)
 |  to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.
 |  start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.
 |  These are exactly the valid indices for a list of 4 elements.
 |  When step is given, it specifies the increment (or decrement).
 |  
 |  Methods defined here:
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(...)
 |      Return a reverse iterator.
 |  
 |  count(...)
 |      rangeobject.count(value) -> integer -- return number of occurrences of value
 |  
 |  index(...)
 |      rangeobject.index(value, [start, [stop]]) -> integer -- return index of value.
 |      Raise ValueError if the value is not present.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  start
 |  
 |  step
 |  
 |  stop
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.interpolate.interpolate.xrange,interpolate.interpolate,range,"Python Library Documentation: class range in module builtins

class range(object)
 |  range(stop) -> range object
 |  range(start, stop[, step]) -> range object
 |  
 |  Return an object that produces a sequence of integers from start (inclusive)
 |  to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.
 |  start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.
 |  These are exactly the valid indices for a list of 4 elements.
 |  When step is given, it specifies the increment (or decrement).
 |  
 |  Methods defined here:
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(...)
 |      Return a reverse iterator.
 |  
 |  count(...)
 |      rangeobject.count(value) -> integer -- return number of occurrences of value
 |  
 |  index(...)
 |      rangeobject.index(value, [start, [stop]]) -> integer -- return index of value.
 |      Raise ValueError if the value is not present.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  start
 |  
 |  step
 |  
 |  stop
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.interpolate.ndgriddata.CloughTocher2DInterpolator,interpolate.ndgriddata,CloughTocher2DInterpolator,"Python Library Documentation: class CloughTocher2DInterpolator in module scipy.interpolate.interpnd

class CloughTocher2DInterpolator(NDInterpolatorBase)
 |  CloughTocher2DInterpolator(points, values, tol=1e-6)
 |  
 |  Piecewise cubic, C1 smooth, curvature-minimizing interpolant in 2D.
 |  
 |  .. versionadded:: 0.9
 |  
 |  Methods
 |  -------
 |  __call__
 |  
 |  Parameters
 |  ----------
 |  points : ndarray of floats, shape (npoints, ndims); or Delaunay
 |      Data point coordinates, or a precomputed Delaunay triangulation.
 |  values : ndarray of float or complex, shape (npoints, ...)
 |      Data values.
 |  fill_value : float, optional
 |      Value used to fill in for requested points outside of the
 |      convex hull of the input points.  If not provided, then
 |      the default is ``nan``.
 |  tol : float, optional
 |      Absolute/relative tolerance for gradient estimation.
 |  maxiter : int, optional
 |      Maximum number of iterations in gradient estimation.
 |  rescale : bool, optional
 |      Rescale points to unit cube before performing interpolation.
 |      This is useful if some of the input dimensions have
 |      incommensurable units and differ by many orders of magnitude.
 |  
 |  Notes
 |  -----
 |  The interpolant is constructed by triangulating the input data
 |  with Qhull [1]_, and constructing a piecewise cubic
 |  interpolating Bezier polynomial on each triangle, using a
 |  Clough-Tocher scheme [CT]_.  The interpolant is guaranteed to be
 |  continuously differentiable.
 |  
 |  The gradients of the interpolant are chosen so that the curvature
 |  of the interpolating surface is approximatively minimized. The
 |  gradients necessary for this are estimated using the global
 |  algorithm described in [Nielson83,Renka84]_.
 |  
 |  References
 |  ----------
 |  .. [1] http://www.qhull.org/
 |  
 |  .. [CT] See, for example,
 |     P. Alfeld,
 |     ''A trivariate Clough-Tocher scheme for tetrahedral data''.
 |     Computer Aided Geometric Design, 1, 169 (1984);
 |     G. Farin,
 |     ''Triangular Bernstein-Bezier patches''.
 |     Computer Aided Geometric Design, 3, 83 (1986).
 |  
 |  .. [Nielson83] G. Nielson,
 |     ''A method for interpolating scattered data based upon a minimum norm
 |     network''.
 |     Math. Comp., 40, 253 (1983).
 |  
 |  .. [Renka84] R. J. Renka and A. K. Cline.
 |     ''A Triangle-based C1 interpolation method.'',
 |     Rocky Mountain J. Math., 14, 223 (1984).
 |  
 |  Method resolution order:
 |      CloughTocher2DInterpolator
 |      NDInterpolatorBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, points, values, fill_value=nan, tol=1e-06, maxiter=400, rescale=False)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from NDInterpolatorBase:
 |  
 |  __call__(self, *args)
 |      interpolator(xi)
 |      
 |      Evaluate interpolator at given points.
 |      
 |      Parameters
 |      ----------
 |      xi : ndarray of float, shape (..., ndim)
 |          Points where to interpolate data at.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from NDInterpolatorBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, points, values, fill_value=nan, tol=1e-06, maxiter=400, rescale=False)',)",scipy,1.1.0,scipy.interpolate.ndgriddata.CloughTocher2DInterpolator,interpolate.ndgriddata,CloughTocher2DInterpolator,"Python Library Documentation: class CloughTocher2DInterpolator in module scipy.interpolate.interpnd

class CloughTocher2DInterpolator(NDInterpolatorBase)
 |  CloughTocher2DInterpolator(points, values, tol=1e-6)
 |  
 |  Piecewise cubic, C1 smooth, curvature-minimizing interpolant in 2D.
 |  
 |  .. versionadded:: 0.9
 |  
 |  Methods
 |  -------
 |  __call__
 |  
 |  Parameters
 |  ----------
 |  points : ndarray of floats, shape (npoints, ndims); or Delaunay
 |      Data point coordinates, or a precomputed Delaunay triangulation.
 |  values : ndarray of float or complex, shape (npoints, ...)
 |      Data values.
 |  fill_value : float, optional
 |      Value used to fill in for requested points outside of the
 |      convex hull of the input points.  If not provided, then
 |      the default is ``nan``.
 |  tol : float, optional
 |      Absolute/relative tolerance for gradient estimation.
 |  maxiter : int, optional
 |      Maximum number of iterations in gradient estimation.
 |  rescale : bool, optional
 |      Rescale points to unit cube before performing interpolation.
 |      This is useful if some of the input dimensions have
 |      incommensurable units and differ by many orders of magnitude.
 |  
 |  Notes
 |  -----
 |  The interpolant is constructed by triangulating the input data
 |  with Qhull [1]_, and constructing a piecewise cubic
 |  interpolating Bezier polynomial on each triangle, using a
 |  Clough-Tocher scheme [CT]_.  The interpolant is guaranteed to be
 |  continuously differentiable.
 |  
 |  The gradients of the interpolant are chosen so that the curvature
 |  of the interpolating surface is approximatively minimized. The
 |  gradients necessary for this are estimated using the global
 |  algorithm described in [Nielson83,Renka84]_.
 |  
 |  References
 |  ----------
 |  .. [1] http://www.qhull.org/
 |  
 |  .. [CT] See, for example,
 |     P. Alfeld,
 |     ''A trivariate Clough-Tocher scheme for tetrahedral data''.
 |     Computer Aided Geometric Design, 1, 169 (1984);
 |     G. Farin,
 |     ''Triangular Bernstein-Bezier patches''.
 |     Computer Aided Geometric Design, 3, 83 (1986).
 |  
 |  .. [Nielson83] G. Nielson,
 |     ''A method for interpolating scattered data based upon a minimum norm
 |     network''.
 |     Math. Comp., 40, 253 (1983).
 |  
 |  .. [Renka84] R. J. Renka and A. K. Cline.
 |     ''A Triangle-based C1 interpolation method.'',
 |     Rocky Mountain J. Math., 14, 223 (1984).
 |  
 |  Method resolution order:
 |      CloughTocher2DInterpolator
 |      NDInterpolatorBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, points, values, fill_value=nan, tol=1e-06, maxiter=400, rescale=False)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from NDInterpolatorBase:
 |  
 |  __call__(self, *args)
 |      interpolator(xi)
 |      
 |      Evaluate interpolator at given points.
 |      
 |      Parameters
 |      ----------
 |      xi : ndarray of float, shape (..., ndim)
 |          Points where to interpolate data at.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from NDInterpolatorBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'points', 'values', 'fill_value', 'tol', 'maxiter', 'rescale')","(nan, nan, nan, nan, 1e-06, 400, False)","(nan, nan, nan, nan, 'float', 'int', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, points, values, fill_value=nan, tol=1e-06, maxiter=400, rescale=False)',)"
scipy,1.1.0,scipy.interpolate.ndgriddata.LinearNDInterpolator,interpolate.ndgriddata,LinearNDInterpolator,"Python Library Documentation: class LinearNDInterpolator in module scipy.interpolate.interpnd

class LinearNDInterpolator(NDInterpolatorBase)
 |  LinearNDInterpolator(points, values, fill_value=np.nan, rescale=False)
 |  
 |  Piecewise linear interpolant in N dimensions.
 |  
 |  .. versionadded:: 0.9
 |  
 |  Methods
 |  -------
 |  __call__
 |  
 |  Parameters
 |  ----------
 |  points : ndarray of floats, shape (npoints, ndims); or Delaunay
 |      Data point coordinates, or a precomputed Delaunay triangulation.
 |  values : ndarray of float or complex, shape (npoints, ...)
 |      Data values.
 |  fill_value : float, optional
 |      Value used to fill in for requested points outside of the
 |      convex hull of the input points.  If not provided, then
 |      the default is ``nan``.
 |  rescale : bool, optional
 |      Rescale points to unit cube before performing interpolation.
 |      This is useful if some of the input dimensions have
 |      incommensurable units and differ by many orders of magnitude.
 |  
 |  Notes
 |  -----
 |  The interpolant is constructed by triangulating the input data
 |  with Qhull [1]_, and on each triangle performing linear
 |  barycentric interpolation.
 |  
 |  References
 |  ----------
 |  .. [1] http://www.qhull.org/
 |  
 |  Method resolution order:
 |      LinearNDInterpolator
 |      NDInterpolatorBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, points, values, fill_value=nan, rescale=False)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from NDInterpolatorBase:
 |  
 |  __call__(self, *args)
 |      interpolator(xi)
 |      
 |      Evaluate interpolator at given points.
 |      
 |      Parameters
 |      ----------
 |      xi : ndarray of float, shape (..., ndim)
 |          Points where to interpolate data at.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from NDInterpolatorBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, points, values, fill_value=nan, rescale=False)',)",scipy,1.1.0,scipy.interpolate.ndgriddata.LinearNDInterpolator,interpolate.ndgriddata,LinearNDInterpolator,"Python Library Documentation: class LinearNDInterpolator in module scipy.interpolate.interpnd

class LinearNDInterpolator(NDInterpolatorBase)
 |  LinearNDInterpolator(points, values, fill_value=np.nan, rescale=False)
 |  
 |  Piecewise linear interpolant in N dimensions.
 |  
 |  .. versionadded:: 0.9
 |  
 |  Methods
 |  -------
 |  __call__
 |  
 |  Parameters
 |  ----------
 |  points : ndarray of floats, shape (npoints, ndims); or Delaunay
 |      Data point coordinates, or a precomputed Delaunay triangulation.
 |  values : ndarray of float or complex, shape (npoints, ...)
 |      Data values.
 |  fill_value : float, optional
 |      Value used to fill in for requested points outside of the
 |      convex hull of the input points.  If not provided, then
 |      the default is ``nan``.
 |  rescale : bool, optional
 |      Rescale points to unit cube before performing interpolation.
 |      This is useful if some of the input dimensions have
 |      incommensurable units and differ by many orders of magnitude.
 |  
 |  Notes
 |  -----
 |  The interpolant is constructed by triangulating the input data
 |  with Qhull [1]_, and on each triangle performing linear
 |  barycentric interpolation.
 |  
 |  References
 |  ----------
 |  .. [1] http://www.qhull.org/
 |  
 |  Method resolution order:
 |      LinearNDInterpolator
 |      NDInterpolatorBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, points, values, fill_value=nan, rescale=False)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from NDInterpolatorBase:
 |  
 |  __call__(self, *args)
 |      interpolator(xi)
 |      
 |      Evaluate interpolator at given points.
 |      
 |      Parameters
 |      ----------
 |      xi : ndarray of float, shape (..., ndim)
 |          Points where to interpolate data at.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from NDInterpolatorBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'points', 'values', 'fill_value', 'rescale')","(nan, nan, nan, nan, False)","(nan, nan, nan, nan, 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, points, values, fill_value=nan, rescale=False)',)"
scipy,1.1.0,scipy.interpolate.ndgriddata.NDInterpolatorBase,interpolate.ndgriddata,NDInterpolatorBase,"Python Library Documentation: class NDInterpolatorBase in module scipy.interpolate.interpnd

class NDInterpolatorBase(builtins.object)
 |  Common routines for interpolators.
 |  
 |  .. versionadded:: 0.9
 |  
 |  Methods defined here:
 |  
 |  __call__(self, *args)
 |      interpolator(xi)
 |      
 |      Evaluate interpolator at given points.
 |      
 |      Parameters
 |      ----------
 |      xi : ndarray of float, shape (..., ndim)
 |          Points where to interpolate data at.
 |  
 |  __init__(self, points, values, fill_value=nan, ndim=None, rescale=False, need_contiguous=True, need_values=True)
 |      Check shape of points and values arrays, and reshape values to
 |      (npoints, nvalues).  Ensure the `points` and values arrays are
 |      C-contiguous, and of correct type.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, points, values, fill_value=nan, ndim=None, rescale=False, need_contiguous=True, need_values=True)',)",scipy,1.1.0,scipy.interpolate.ndgriddata.NDInterpolatorBase,interpolate.ndgriddata,NDInterpolatorBase,"Python Library Documentation: class NDInterpolatorBase in module scipy.interpolate.interpnd

class NDInterpolatorBase(builtins.object)
 |  Common routines for interpolators.
 |  
 |  .. versionadded:: 0.9
 |  
 |  Methods defined here:
 |  
 |  __call__(self, *args)
 |      interpolator(xi)
 |      
 |      Evaluate interpolator at given points.
 |      
 |      Parameters
 |      ----------
 |      xi : ndarray of float, shape (..., ndim)
 |          Points where to interpolate data at.
 |  
 |  __init__(self, points, values, fill_value=nan, ndim=None, rescale=False, need_contiguous=True, need_values=True)
 |      Check shape of points and values arrays, and reshape values to
 |      (npoints, nvalues).  Ensure the `points` and values arrays are
 |      C-contiguous, and of correct type.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'points', 'values', 'fill_value', 'ndim', 'rescale', 'need_contiguous', 'need_values')","(nan, nan, nan, nan, None, False, True, True)","(nan, nan, nan, nan, 'NoneType', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, points, values, fill_value=nan, ndim=None, rescale=False, need_contiguous=True, need_values=True)',)"
scipy,1.1.0,scipy.interpolate.ndgriddata.NearestNDInterpolator,interpolate.ndgriddata,NearestNDInterpolator,"Python Library Documentation: class NearestNDInterpolator in module scipy.interpolate.ndgriddata

class NearestNDInterpolator(scipy.interpolate.interpnd.NDInterpolatorBase)
 |  NearestNDInterpolator(x, y)
 |  
 |  Nearest-neighbour interpolation in N dimensions.
 |  
 |  .. versionadded:: 0.9
 |  
 |  Methods
 |  -------
 |  __call__
 |  
 |  Parameters
 |  ----------
 |  x : (Npoints, Ndims) ndarray of floats
 |      Data point coordinates.
 |  y : (Npoints,) ndarray of float or complex
 |      Data values.
 |  rescale : boolean, optional
 |      Rescale points to unit cube before performing interpolation.
 |      This is useful if some of the input dimensions have
 |      incommensurable units and differ by many orders of magnitude.
 |  
 |      .. versionadded:: 0.14.0
 |  tree_options : dict, optional
 |      Options passed to the underlying ``cKDTree``.
 |  
 |      .. versionadded:: 0.17.0
 |  
 |  
 |  Notes
 |  -----
 |  Uses ``scipy.spatial.cKDTree``
 |  
 |  Method resolution order:
 |      NearestNDInterpolator
 |      scipy.interpolate.interpnd.NDInterpolatorBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __call__(self, *args)
 |      Evaluate interpolator at given points.
 |      
 |      Parameters
 |      ----------
 |      xi : ndarray of float, shape (..., ndim)
 |          Points where to interpolate data at.
 |  
 |  __init__(self, x, y, rescale=False, tree_options=None)
 |      Check shape of points and values arrays, and reshape values to
 |      (npoints, nvalues).  Ensure the `points` and values arrays are
 |      C-contiguous, and of correct type.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.interpolate.interpnd.NDInterpolatorBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, x, y, rescale=False, tree_options=None)',)",scipy,1.1.0,scipy.interpolate.ndgriddata.NearestNDInterpolator,interpolate.ndgriddata,NearestNDInterpolator,"Python Library Documentation: class NearestNDInterpolator in module scipy.interpolate.ndgriddata

class NearestNDInterpolator(scipy.interpolate.interpnd.NDInterpolatorBase)
 |  NearestNDInterpolator(x, y)
 |  
 |  Nearest-neighbour interpolation in N dimensions.
 |  
 |  .. versionadded:: 0.9
 |  
 |  Methods
 |  -------
 |  __call__
 |  
 |  Parameters
 |  ----------
 |  x : (Npoints, Ndims) ndarray of floats
 |      Data point coordinates.
 |  y : (Npoints,) ndarray of float or complex
 |      Data values.
 |  rescale : boolean, optional
 |      Rescale points to unit cube before performing interpolation.
 |      This is useful if some of the input dimensions have
 |      incommensurable units and differ by many orders of magnitude.
 |  
 |      .. versionadded:: 0.14.0
 |  tree_options : dict, optional
 |      Options passed to the underlying ``cKDTree``.
 |  
 |      .. versionadded:: 0.17.0
 |  
 |  
 |  Notes
 |  -----
 |  Uses ``scipy.spatial.cKDTree``
 |  
 |  Method resolution order:
 |      NearestNDInterpolator
 |      scipy.interpolate.interpnd.NDInterpolatorBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __call__(self, *args)
 |      Evaluate interpolator at given points.
 |      
 |      Parameters
 |      ----------
 |      xi : ndarray of float, shape (..., ndim)
 |          Points where to interpolate data at.
 |  
 |  __init__(self, x, y, rescale=False, tree_options=None)
 |      Check shape of points and values arrays, and reshape values to
 |      (npoints, nvalues).  Ensure the `points` and values arrays are
 |      C-contiguous, and of correct type.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.interpolate.interpnd.NDInterpolatorBase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'x', 'y', 'rescale', 'tree_options')","(nan, nan, nan, False, None)","(nan, nan, nan, 'bool', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, x, y, rescale=False, tree_options=None)',)"
scipy,1.1.0,scipy.interpolate.ndgriddata.cKDTree,interpolate.ndgriddata,cKDTree,"Python Library Documentation: class cKDTree in module scipy.spatial.ckdtree

class cKDTree(builtins.object)
 |  cKDTree(data, leafsize=16, compact_nodes=True, copy_data=False,
 |          balanced_tree=True)
 |  
 |  kd-tree for quick nearest-neighbor lookup
 |  
 |  This class provides an index into a set of k-dimensional points
 |  which can be used to rapidly look up the nearest neighbors of any
 |  point. 
 |  
 |  The algorithm used is described in Maneewongvatana and Mount 1999. 
 |  The general idea is that the kd-tree is a binary trie, each of whose
 |  nodes represents an axis-aligned hyperrectangle. Each node specifies
 |  an axis and splits the set of points based on whether their coordinate
 |  along that axis is greater than or less than a particular value. 
 |  
 |  During construction, the axis and splitting point are chosen by the 
 |  ""sliding midpoint"" rule, which ensures that the cells do not all
 |  become long and thin. 
 |  
 |  The tree can be queried for the r closest neighbors of any given point 
 |  (optionally returning only those within some maximum distance of the 
 |  point). It can also be queried, with a substantial gain in efficiency, 
 |  for the r approximate closest neighbors.
 |  
 |  For large dimensions (20 is already large) do not expect this to run 
 |  significantly faster than brute force. High-dimensional nearest-neighbor
 |  queries are a substantial open problem in computer science.
 |  
 |  Parameters
 |  ----------
 |  data : array_like, shape (n,m)
 |      The n data points of dimension m to be indexed. This array is 
 |      not copied unless this is necessary to produce a contiguous 
 |      array of doubles, and so modifying this data will result in 
 |      bogus results. The data are also copied if the kd-tree is built
 |      with copy_data=True.
 |  leafsize : positive int, optional
 |      The number of points at which the algorithm switches over to
 |      brute-force. Default: 16.
 |  compact_nodes : bool, optional    
 |      If True, the kd-tree is built to shrink the hyperrectangles to
 |      the actual data range. This usually gives a more compact tree that 
 |      is robust against degenerated input data and gives faster queries 
 |      at the expense of longer build time. Default: True.
 |  copy_data : bool, optional
 |      If True the data is always copied to protect the kd-tree against 
 |      data corruption. Default: False.
 |  balanced_tree : bool, optional    
 |      If True, the median is used to split the hyperrectangles instead of 
 |      the midpoint. This usually gives a more compact tree and 
 |      faster queries at the expense of longer build time. Default: True.
 |  boxsize : array_like or scalar, optional
 |      Apply a m-d toroidal topology to the KDTree.. The topology is generated 
 |      by :math:`x_i + n_i L_i` where :math:`n_i` are integers and :math:`L_i`
 |      is the boxsize along i-th dimension. The input data shall be wrapped 
 |      into :math:`[0, L_i)`. A ValueError is raised if any of the data is
 |      outside of this bound.
 |  
 |  Attributes
 |  ----------
 |  data : ndarray, shape (n,m)
 |      The n data points of dimension m to be indexed. This array is
 |      not copied unless this is necessary to produce a contiguous
 |      array of doubles. The data are also copied if the kd-tree is built
 |      with `copy_data=True`.
 |  leafsize : positive int
 |      The number of points at which the algorithm switches over to
 |      brute-force.
 |  m : int
 |      The dimension of a single data-point.
 |  n : int
 |      The number of data points.
 |  maxes : ndarray, shape (m,)
 |      The maximum value in each dimension of the n data points.
 |  mins : ndarray, shape (m,)
 |      The minimum value in each dimension of the n data points.
 |  tree : object, class cKDTreeNode
 |      This class exposes a Python view of the root node in the cKDTree object.
 |  size : int
 |      The number of nodes in the tree.
 |  
 |  See Also
 |  --------
 |  KDTree : Implementation of `cKDTree` in pure Python
 |  
 |  Methods defined here:
 |  
 |  __getstate__(...)
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __setstate__(...)
 |  
 |  count_neighbors(...)
 |      count_neighbors(self, other, r, p=2., weights=None, cumulative=True)
 |      
 |      Count how many nearby pairs can be formed. (pair-counting)
 |      
 |      Count the number of pairs (x1,x2) can be formed, with x1 drawn
 |      from self and x2 drawn from ``other``, and where
 |      ``distance(x1, x2, p) <= r``.
 |      
 |      Data points on self and other are optionally weighted by the ``weights``
 |      argument. (See below)
 |      
 |      The algorithm we implement here is based on [1]_. See notes for further discussion.
 |      
 |      Parameters
 |      ----------
 |      other : cKDTree instance
 |          The other tree to draw points from, can be the same tree as self.
 |      r : float or one-dimensional array of floats
 |          The radius to produce a count for. Multiple radii are searched with
 |          a single tree traversal. 
 |          If the count is non-cumulative(``cumulative=False``), ``r`` defines 
 |          the edges of the bins, and must be non-decreasing.
 |      p : float, optional 
 |          1<=p<=infinity. 
 |          Which Minkowski p-norm to use.
 |          Default 2.0.
 |      weights : tuple, array_like, or None, optional
 |          If None, the pair-counting is unweighted.
 |          If given as a tuple, weights[0] is the weights of points in ``self``, and
 |          weights[1] is the weights of points in ``other``; either can be None to 
 |          indicate the points are unweighted.
 |          If given as an array_like, weights is the weights of points in ``self``
 |          and ``other``. For this to make sense, ``self`` and ``other`` must be the
 |          same tree. If ``self`` and ``other`` are two different trees, a ``ValueError``
 |          is raised.
 |          Default: None
 |      cumulative : bool, optional
 |          Whether the returned counts are cumulative. When cumulative is set to ``False``
 |          the algorithm is optimized to work with a large number of bins (>10) specified
 |          by ``r``. When ``cumulative`` is set to True, the algorithm is optimized to work
 |          with a small number of ``r``. Default: True
 |      
 |      Returns
 |      -------
 |      result : scalar or 1-D array
 |          The number of pairs. For unweighted counts, the result is integer.
 |          For weighted counts, the result is float.
 |          If cumulative is False, ``result[i]`` contains the counts with
 |          ``(-inf if i == 0 else r[i-1]) < R <= r[i]``
 |      
 |      Notes
 |      -----
 |      Pair-counting is the basic operation used to calculate the two point
 |      correlation functions from a data set composed of position of objects.
 |      
 |      Two point correlation function measures the clustering of objects and
 |      is widely used in cosmology to quantify the large scale structure
 |      in our Universe, but it may be useful for data analysis in other fields
 |      where self-similar assembly of objects also occur.
 |      
 |      The Landy-Szalay estimator for the two point correlation function of
 |      ``D`` measures the clustering signal in ``D``. [2]_
 |      
 |      For example, given the position of two sets of objects,
 |      
 |      - objects ``D`` (data) contains the clustering signal, and
 |      
 |      - objects ``R`` (random) that contains no signal,
 |      
 |      .. math::
 |      
 |           \xi(r) = \frac{<D, D> - 2 f <D, R> + f^2<R, R>}{f^2<R, R>},
 |      
 |      where the brackets represents counting pairs between two data sets
 |      in a finite bin around ``r`` (distance), corresponding to setting
 |      `cumulative=False`, and ``f = float(len(D)) / float(len(R))`` is the
 |      ratio between number of objects from data and random.
 |      
 |      The algorithm implemented here is loosely based on the dual-tree
 |      algorithm described in [1]_. We switch between two different
 |      pair-cumulation scheme depending on the setting of ``cumulative``.
 |      The computing time of the method we use when for
 |      ``cumulative == False`` does not scale with the total number of bins.
 |      The algorithm for ``cumulative == True`` scales linearly with the
 |      number of bins, though it is slightly faster when only
 |      1 or 2 bins are used. [5]_.
 |      
 |      As an extension to the naive pair-counting,
 |      weighted pair-counting counts the product of weights instead
 |      of number of pairs.
 |      Weighted pair-counting is used to estimate marked correlation functions
 |      ([3]_, section 2.2),
 |      or to properly calculate the average of data per distance bin
 |      (e.g. [4]_, section 2.1 on redshift).
 |      
 |      .. [1] Gray and Moore,
 |             ""N-body problems in statistical learning"",
 |             Mining the sky, 2000,
 |             https://arxiv.org/abs/astro-ph/0012333
 |      
 |      .. [2] Landy and Szalay,
 |             ""Bias and variance of angular correlation functions"",
 |             The Astrophysical Journal, 1993,
 |             http://adsabs.harvard.edu/abs/1993ApJ...412...64L
 |      
 |      .. [3] Sheth, Connolly and Skibba,
 |             ""Marked correlations in galaxy formation models"",
 |             Arxiv e-print, 2005,
 |             https://arxiv.org/abs/astro-ph/0511773
 |      
 |      .. [4] Hawkins, et al.,
 |             ""The 2dF Galaxy Redshift Survey: correlation functions,
 |             peculiar velocities and the matter density of the Universe"",
 |             Monthly Notices of the Royal Astronomical Society, 2002,
 |             http://adsabs.harvard.edu/abs/2003MNRAS.346...78H
 |      
 |      .. [5] https://github.com/scipy/scipy/pull/5647#issuecomment-168474926
 |  
 |  query(...)
 |      query(self, x, k=1, eps=0, p=2, distance_upper_bound=np.inf, n_jobs=1)
 |      
 |      Query the kd-tree for nearest neighbors
 |      
 |      Parameters
 |      ----------
 |      x : array_like, last dimension self.m
 |          An array of points to query.
 |      k : list of integer or integer
 |          The list of k-th nearest neighbors to return. If k is an 
 |          integer it is treated as a list of [1, ... k] (range(1, k+1)).
 |          Note that the counting starts from 1.
 |      eps : non-negative float
 |          Return approximate nearest neighbors; the k-th returned value 
 |          is guaranteed to be no further than (1+eps) times the 
 |          distance to the real k-th nearest neighbor.
 |      p : float, 1<=p<=infinity
 |          Which Minkowski p-norm to use. 
 |          1 is the sum-of-absolute-values ""Manhattan"" distance
 |          2 is the usual Euclidean distance
 |          infinity is the maximum-coordinate-difference distance
 |      distance_upper_bound : nonnegative float
 |          Return only neighbors within this distance.  This is used to prune
 |          tree searches, so if you are doing a series of nearest-neighbor
 |          queries, it may help to supply the distance to the nearest neighbor
 |          of the most recent point.
 |      n_jobs : int, optional
 |          Number of jobs to schedule for parallel processing. If -1 is given
 |          all processors are used. Default: 1.
 |                      
 |      Returns
 |      -------
 |      d : array of floats
 |          The distances to the nearest neighbors. 
 |          If ``x`` has shape ``tuple+(self.m,)``, then ``d`` has shape ``tuple+(k,)``.
 |          When k == 1, the last dimension of the output is squeezed.
 |          Missing neighbors are indicated with infinite distances.
 |      i : ndarray of ints
 |          The locations of the neighbors in ``self.data``.
 |          If ``x`` has shape ``tuple+(self.m,)``, then ``i`` has shape ``tuple+(k,)``.
 |          When k == 1, the last dimension of the output is squeezed.
 |          Missing neighbors are indicated with ``self.n``.
 |      
 |      Notes
 |      -----
 |      If the KD-Tree is periodic, the position ``x`` is wrapped into the
 |      box.
 |      
 |      When the input k is a list, a query for arange(max(k)) is performed, but
 |      only columns that store the requested values of k are preserved. This is 
 |      implemented in a manner that reduces memory usage.
 |      
 |      Examples
 |      --------
 |      
 |      >>> import numpy as np
 |      >>> from scipy.spatial import cKDTree
 |      >>> x, y = np.mgrid[0:5, 2:8]
 |      >>> tree = cKDTree(np.c_[x.ravel(), y.ravel()])
 |      
 |      To query the nearest neighbours and return squeezed result, use
 |      
 |      >>> dd, ii = tree.query([[0, 0], [2.1, 2.9]], k=1)
 |      >>> print(dd, ii)
 |      [2.         0.14142136] [ 0 13]
 |      
 |      To query the nearest neighbours and return unsqueezed result, use
 |      
 |      >>> dd, ii = tree.query([[0, 0], [2.1, 2.9]], k=[1])
 |      >>> print(dd, ii)
 |      [[2.        ]
 |       [0.14142136]] [[ 0]
 |       [13]]
 |      
 |      To query the second nearest neighbours and return unsqueezed result, use
 |      
 |      >>> dd, ii = tree.query([[0, 0], [2.1, 2.9]], k=[2])
 |      >>> print(dd, ii)
 |      [[2.23606798]
 |       [0.90553851]] [[ 6]
 |       [12]]
 |      
 |      To query the first and second nearest neighbours, use
 |      
 |      >>> dd, ii = tree.query([[0, 0], [2.1, 2.9]], k=2)
 |      >>> print(dd, ii)
 |      [[2.         2.23606798]
 |       [0.14142136 0.90553851]] [[ 0  6]
 |       [13 12]]
 |      
 |      or, be more specific
 |      
 |      >>> dd, ii = tree.query([[0, 0], [2.1, 2.9]], k=[1, 2])
 |      >>> print(dd, ii)
 |      [[2.         2.23606798]
 |       [0.14142136 0.90553851]] [[ 0  6]
 |       [13 12]]
 |  
 |  query_ball_point(...)
 |      query_ball_point(self, x, r, p=2., eps=0)
 |      
 |      Find all points within distance r of point(s) x.
 |      
 |      Parameters
 |      ----------
 |      x : array_like, shape tuple + (self.m,)
 |          The point or points to search for neighbors of.
 |      r : positive float
 |          The radius of points to return.
 |      p : float, optional
 |          Which Minkowski p-norm to use.  Should be in the range [1, inf].
 |      eps : nonnegative float, optional
 |          Approximate search. Branches of the tree are not explored if their
 |          nearest points are further than ``r / (1 + eps)``, and branches are
 |          added in bulk if their furthest points are nearer than
 |          ``r * (1 + eps)``.
 |      n_jobs : int, optional
 |          Number of jobs to schedule for parallel processing. If -1 is given
 |          all processors are used. Default: 1.
 |      
 |      Returns
 |      -------
 |      results : list or array of lists
 |          If `x` is a single point, returns a list of the indices of the
 |          neighbors of `x`. If `x` is an array of points, returns an object
 |          array of shape tuple containing lists of neighbors.
 |      
 |      Notes
 |      -----
 |      If you have many points whose neighbors you want to find, you may save
 |      substantial amounts of time by putting them in a cKDTree and using
 |      query_ball_tree.
 |      
 |      Examples
 |      --------
 |      >>> from scipy import spatial
 |      >>> x, y = np.mgrid[0:4, 0:4]
 |      >>> points = np.c_[x.ravel(), y.ravel()]
 |      >>> tree = spatial.cKDTree(points)
 |      >>> tree.query_ball_point([2, 0], 1)
 |      [4, 8, 9, 12]
 |  
 |  query_ball_tree(...)
 |      query_ball_tree(self, other, r, p=2., eps=0)
 |      
 |      Find all pairs of points whose distance is at most r
 |      
 |      Parameters
 |      ----------
 |      other : cKDTree instance
 |          The tree containing points to search against.
 |      r : float
 |          The maximum distance, has to be positive.
 |      p : float, optional
 |          Which Minkowski norm to use.  `p` has to meet the condition
 |          ``1 <= p <= infinity``.
 |      eps : float, optional
 |          Approximate search.  Branches of the tree are not explored
 |          if their nearest points are further than ``r/(1+eps)``, and
 |          branches are added in bulk if their furthest points are nearer
 |          than ``r * (1+eps)``.  `eps` has to be non-negative.
 |      
 |      Returns
 |      -------
 |      results : list of lists
 |          For each element ``self.data[i]`` of this tree, ``results[i]`` is a
 |          list of the indices of its neighbors in ``other.data``.
 |  
 |  query_pairs(...)
 |      query_pairs(self, r, p=2., eps=0)
 |      
 |      Find all pairs of points whose distance is at most r.
 |      
 |      Parameters
 |      ----------
 |      r : positive float
 |          The maximum distance.
 |      p : float, optional
 |          Which Minkowski norm to use.  ``p`` has to meet the condition
 |          ``1 <= p <= infinity``.
 |      eps : float, optional
 |          Approximate search.  Branches of the tree are not explored
 |          if their nearest points are further than ``r/(1+eps)``, and
 |          branches are added in bulk if their furthest points are nearer
 |          than ``r * (1+eps)``.  `eps` has to be non-negative.
 |      output_type : string, optional
 |          Choose the output container, 'set' or 'ndarray'. Default: 'set'
 |      
 |      Returns
 |      -------
 |      results : set or ndarray
 |          Set of pairs ``(i,j)``, with ``i < j``, for which the corresponding
 |          positions are close. If output_type is 'ndarray', an ndarry is 
 |          returned instead of a set.
 |  
 |  sparse_distance_matrix(...)
 |      sparse_distance_matrix(self, other, max_distance, p=2.)
 |      
 |      Compute a sparse distance matrix
 |      
 |      Computes a distance matrix between two cKDTrees, leaving as zero
 |      any distance greater than max_distance.
 |      
 |      Parameters
 |      ----------
 |      other : cKDTree
 |      
 |      max_distance : positive float
 |      
 |      p : float, 1<=p<=infinity
 |          Which Minkowski p-norm to use. 
 |      
 |      output_type : string, optional
 |          Which container to use for output data. Options: 'dok_matrix',
 |          'coo_matrix', 'dict', or 'ndarray'. Default: 'dok_matrix'.
 |      
 |      Returns
 |      -------
 |      result : dok_matrix, coo_matrix, dict or ndarray
 |          Sparse matrix representing the results in ""dictionary of keys"" 
 |          format. If a dict is returned the keys are (i,j) tuples of indices.
 |          If output_type is 'ndarray' a record array with fields 'i', 'j',
 |          and 'k' is returned,
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  boxsize
 |  
 |  data
 |  
 |  indices
 |  
 |  leafsize
 |  
 |  m
 |  
 |  maxes
 |  
 |  mins
 |  
 |  n
 |  
 |  size
 |  
 |  tree
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __pyx_vtable__ = <capsule object NULL>
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.interpolate.ndgriddata.cKDTree,interpolate.ndgriddata,cKDTree,"Python Library Documentation: class cKDTree in module scipy.spatial.ckdtree

class cKDTree(builtins.object)
 |  cKDTree(data, leafsize=16, compact_nodes=True, copy_data=False,
 |          balanced_tree=True)
 |  
 |  kd-tree for quick nearest-neighbor lookup
 |  
 |  This class provides an index into a set of k-dimensional points
 |  which can be used to rapidly look up the nearest neighbors of any
 |  point. 
 |  
 |  The algorithm used is described in Maneewongvatana and Mount 1999. 
 |  The general idea is that the kd-tree is a binary trie, each of whose
 |  nodes represents an axis-aligned hyperrectangle. Each node specifies
 |  an axis and splits the set of points based on whether their coordinate
 |  along that axis is greater than or less than a particular value. 
 |  
 |  During construction, the axis and splitting point are chosen by the 
 |  ""sliding midpoint"" rule, which ensures that the cells do not all
 |  become long and thin. 
 |  
 |  The tree can be queried for the r closest neighbors of any given point 
 |  (optionally returning only those within some maximum distance of the 
 |  point). It can also be queried, with a substantial gain in efficiency, 
 |  for the r approximate closest neighbors.
 |  
 |  For large dimensions (20 is already large) do not expect this to run 
 |  significantly faster than brute force. High-dimensional nearest-neighbor
 |  queries are a substantial open problem in computer science.
 |  
 |  Parameters
 |  ----------
 |  data : array_like, shape (n,m)
 |      The n data points of dimension m to be indexed. This array is 
 |      not copied unless this is necessary to produce a contiguous 
 |      array of doubles, and so modifying this data will result in 
 |      bogus results. The data are also copied if the kd-tree is built
 |      with copy_data=True.
 |  leafsize : positive int, optional
 |      The number of points at which the algorithm switches over to
 |      brute-force. Default: 16.
 |  compact_nodes : bool, optional    
 |      If True, the kd-tree is built to shrink the hyperrectangles to
 |      the actual data range. This usually gives a more compact tree that 
 |      is robust against degenerated input data and gives faster queries 
 |      at the expense of longer build time. Default: True.
 |  copy_data : bool, optional
 |      If True the data is always copied to protect the kd-tree against 
 |      data corruption. Default: False.
 |  balanced_tree : bool, optional    
 |      If True, the median is used to split the hyperrectangles instead of 
 |      the midpoint. This usually gives a more compact tree and 
 |      faster queries at the expense of longer build time. Default: True.
 |  boxsize : array_like or scalar, optional
 |      Apply a m-d toroidal topology to the KDTree.. The topology is generated 
 |      by :math:`x_i + n_i L_i` where :math:`n_i` are integers and :math:`L_i`
 |      is the boxsize along i-th dimension. The input data shall be wrapped 
 |      into :math:`[0, L_i)`. A ValueError is raised if any of the data is
 |      outside of this bound.
 |  
 |  Attributes
 |  ----------
 |  data : ndarray, shape (n,m)
 |      The n data points of dimension m to be indexed. This array is
 |      not copied unless this is necessary to produce a contiguous
 |      array of doubles. The data are also copied if the kd-tree is built
 |      with `copy_data=True`.
 |  leafsize : positive int
 |      The number of points at which the algorithm switches over to
 |      brute-force.
 |  m : int
 |      The dimension of a single data-point.
 |  n : int
 |      The number of data points.
 |  maxes : ndarray, shape (m,)
 |      The maximum value in each dimension of the n data points.
 |  mins : ndarray, shape (m,)
 |      The minimum value in each dimension of the n data points.
 |  tree : object, class cKDTreeNode
 |      This class exposes a Python view of the root node in the cKDTree object.
 |  size : int
 |      The number of nodes in the tree.
 |  
 |  See Also
 |  --------
 |  KDTree : Implementation of `cKDTree` in pure Python
 |  
 |  Methods defined here:
 |  
 |  __getstate__(...)
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __setstate__(...)
 |  
 |  count_neighbors(...)
 |      count_neighbors(self, other, r, p=2., weights=None, cumulative=True)
 |      
 |      Count how many nearby pairs can be formed. (pair-counting)
 |      
 |      Count the number of pairs (x1,x2) can be formed, with x1 drawn
 |      from self and x2 drawn from ``other``, and where
 |      ``distance(x1, x2, p) <= r``.
 |      
 |      Data points on self and other are optionally weighted by the ``weights``
 |      argument. (See below)
 |      
 |      The algorithm we implement here is based on [1]_. See notes for further discussion.
 |      
 |      Parameters
 |      ----------
 |      other : cKDTree instance
 |          The other tree to draw points from, can be the same tree as self.
 |      r : float or one-dimensional array of floats
 |          The radius to produce a count for. Multiple radii are searched with
 |          a single tree traversal. 
 |          If the count is non-cumulative(``cumulative=False``), ``r`` defines 
 |          the edges of the bins, and must be non-decreasing.
 |      p : float, optional 
 |          1<=p<=infinity. 
 |          Which Minkowski p-norm to use.
 |          Default 2.0.
 |      weights : tuple, array_like, or None, optional
 |          If None, the pair-counting is unweighted.
 |          If given as a tuple, weights[0] is the weights of points in ``self``, and
 |          weights[1] is the weights of points in ``other``; either can be None to 
 |          indicate the points are unweighted.
 |          If given as an array_like, weights is the weights of points in ``self``
 |          and ``other``. For this to make sense, ``self`` and ``other`` must be the
 |          same tree. If ``self`` and ``other`` are two different trees, a ``ValueError``
 |          is raised.
 |          Default: None
 |      cumulative : bool, optional
 |          Whether the returned counts are cumulative. When cumulative is set to ``False``
 |          the algorithm is optimized to work with a large number of bins (>10) specified
 |          by ``r``. When ``cumulative`` is set to True, the algorithm is optimized to work
 |          with a small number of ``r``. Default: True
 |      
 |      Returns
 |      -------
 |      result : scalar or 1-D array
 |          The number of pairs. For unweighted counts, the result is integer.
 |          For weighted counts, the result is float.
 |          If cumulative is False, ``result[i]`` contains the counts with
 |          ``(-inf if i == 0 else r[i-1]) < R <= r[i]``
 |      
 |      Notes
 |      -----
 |      Pair-counting is the basic operation used to calculate the two point
 |      correlation functions from a data set composed of position of objects.
 |      
 |      Two point correlation function measures the clustering of objects and
 |      is widely used in cosmology to quantify the large scale structure
 |      in our Universe, but it may be useful for data analysis in other fields
 |      where self-similar assembly of objects also occur.
 |      
 |      The Landy-Szalay estimator for the two point correlation function of
 |      ``D`` measures the clustering signal in ``D``. [2]_
 |      
 |      For example, given the position of two sets of objects,
 |      
 |      - objects ``D`` (data) contains the clustering signal, and
 |      
 |      - objects ``R`` (random) that contains no signal,
 |      
 |      .. math::
 |      
 |           \xi(r) = \frac{<D, D> - 2 f <D, R> + f^2<R, R>}{f^2<R, R>},
 |      
 |      where the brackets represents counting pairs between two data sets
 |      in a finite bin around ``r`` (distance), corresponding to setting
 |      `cumulative=False`, and ``f = float(len(D)) / float(len(R))`` is the
 |      ratio between number of objects from data and random.
 |      
 |      The algorithm implemented here is loosely based on the dual-tree
 |      algorithm described in [1]_. We switch between two different
 |      pair-cumulation scheme depending on the setting of ``cumulative``.
 |      The computing time of the method we use when for
 |      ``cumulative == False`` does not scale with the total number of bins.
 |      The algorithm for ``cumulative == True`` scales linearly with the
 |      number of bins, though it is slightly faster when only
 |      1 or 2 bins are used. [5]_.
 |      
 |      As an extension to the naive pair-counting,
 |      weighted pair-counting counts the product of weights instead
 |      of number of pairs.
 |      Weighted pair-counting is used to estimate marked correlation functions
 |      ([3]_, section 2.2),
 |      or to properly calculate the average of data per distance bin
 |      (e.g. [4]_, section 2.1 on redshift).
 |      
 |      .. [1] Gray and Moore,
 |             ""N-body problems in statistical learning"",
 |             Mining the sky, 2000,
 |             https://arxiv.org/abs/astro-ph/0012333
 |      
 |      .. [2] Landy and Szalay,
 |             ""Bias and variance of angular correlation functions"",
 |             The Astrophysical Journal, 1993,
 |             http://adsabs.harvard.edu/abs/1993ApJ...412...64L
 |      
 |      .. [3] Sheth, Connolly and Skibba,
 |             ""Marked correlations in galaxy formation models"",
 |             Arxiv e-print, 2005,
 |             https://arxiv.org/abs/astro-ph/0511773
 |      
 |      .. [4] Hawkins, et al.,
 |             ""The 2dF Galaxy Redshift Survey: correlation functions,
 |             peculiar velocities and the matter density of the Universe"",
 |             Monthly Notices of the Royal Astronomical Society, 2002,
 |             http://adsabs.harvard.edu/abs/2003MNRAS.346...78H
 |      
 |      .. [5] https://github.com/scipy/scipy/pull/5647#issuecomment-168474926
 |  
 |  query(...)
 |      query(self, x, k=1, eps=0, p=2, distance_upper_bound=np.inf, n_jobs=1)
 |      
 |      Query the kd-tree for nearest neighbors
 |      
 |      Parameters
 |      ----------
 |      x : array_like, last dimension self.m
 |          An array of points to query.
 |      k : list of integer or integer
 |          The list of k-th nearest neighbors to return. If k is an 
 |          integer it is treated as a list of [1, ... k] (range(1, k+1)).
 |          Note that the counting starts from 1.
 |      eps : non-negative float
 |          Return approximate nearest neighbors; the k-th returned value 
 |          is guaranteed to be no further than (1+eps) times the 
 |          distance to the real k-th nearest neighbor.
 |      p : float, 1<=p<=infinity
 |          Which Minkowski p-norm to use. 
 |          1 is the sum-of-absolute-values ""Manhattan"" distance
 |          2 is the usual Euclidean distance
 |          infinity is the maximum-coordinate-difference distance
 |      distance_upper_bound : nonnegative float
 |          Return only neighbors within this distance.  This is used to prune
 |          tree searches, so if you are doing a series of nearest-neighbor
 |          queries, it may help to supply the distance to the nearest neighbor
 |          of the most recent point.
 |      n_jobs : int, optional
 |          Number of jobs to schedule for parallel processing. If -1 is given
 |          all processors are used. Default: 1.
 |                      
 |      Returns
 |      -------
 |      d : array of floats
 |          The distances to the nearest neighbors. 
 |          If ``x`` has shape ``tuple+(self.m,)``, then ``d`` has shape ``tuple+(k,)``.
 |          When k == 1, the last dimension of the output is squeezed.
 |          Missing neighbors are indicated with infinite distances.
 |      i : ndarray of ints
 |          The locations of the neighbors in ``self.data``.
 |          If ``x`` has shape ``tuple+(self.m,)``, then ``i`` has shape ``tuple+(k,)``.
 |          When k == 1, the last dimension of the output is squeezed.
 |          Missing neighbors are indicated with ``self.n``.
 |      
 |      Notes
 |      -----
 |      If the KD-Tree is periodic, the position ``x`` is wrapped into the
 |      box.
 |      
 |      When the input k is a list, a query for arange(max(k)) is performed, but
 |      only columns that store the requested values of k are preserved. This is 
 |      implemented in a manner that reduces memory usage.
 |      
 |      Examples
 |      --------
 |      
 |      >>> import numpy as np
 |      >>> from scipy.spatial import cKDTree
 |      >>> x, y = np.mgrid[0:5, 2:8]
 |      >>> tree = cKDTree(np.c_[x.ravel(), y.ravel()])
 |      
 |      To query the nearest neighbours and return squeezed result, use
 |      
 |      >>> dd, ii = tree.query([[0, 0], [2.1, 2.9]], k=1)
 |      >>> print(dd, ii)
 |      [2.         0.14142136] [ 0 13]
 |      
 |      To query the nearest neighbours and return unsqueezed result, use
 |      
 |      >>> dd, ii = tree.query([[0, 0], [2.1, 2.9]], k=[1])
 |      >>> print(dd, ii)
 |      [[2.        ]
 |       [0.14142136]] [[ 0]
 |       [13]]
 |      
 |      To query the second nearest neighbours and return unsqueezed result, use
 |      
 |      >>> dd, ii = tree.query([[0, 0], [2.1, 2.9]], k=[2])
 |      >>> print(dd, ii)
 |      [[2.23606798]
 |       [0.90553851]] [[ 6]
 |       [12]]
 |      
 |      To query the first and second nearest neighbours, use
 |      
 |      >>> dd, ii = tree.query([[0, 0], [2.1, 2.9]], k=2)
 |      >>> print(dd, ii)
 |      [[2.         2.23606798]
 |       [0.14142136 0.90553851]] [[ 0  6]
 |       [13 12]]
 |      
 |      or, be more specific
 |      
 |      >>> dd, ii = tree.query([[0, 0], [2.1, 2.9]], k=[1, 2])
 |      >>> print(dd, ii)
 |      [[2.         2.23606798]
 |       [0.14142136 0.90553851]] [[ 0  6]
 |       [13 12]]
 |  
 |  query_ball_point(...)
 |      query_ball_point(self, x, r, p=2., eps=0)
 |      
 |      Find all points within distance r of point(s) x.
 |      
 |      Parameters
 |      ----------
 |      x : array_like, shape tuple + (self.m,)
 |          The point or points to search for neighbors of.
 |      r : positive float
 |          The radius of points to return.
 |      p : float, optional
 |          Which Minkowski p-norm to use.  Should be in the range [1, inf].
 |      eps : nonnegative float, optional
 |          Approximate search. Branches of the tree are not explored if their
 |          nearest points are further than ``r / (1 + eps)``, and branches are
 |          added in bulk if their furthest points are nearer than
 |          ``r * (1 + eps)``.
 |      n_jobs : int, optional
 |          Number of jobs to schedule for parallel processing. If -1 is given
 |          all processors are used. Default: 1.
 |      
 |      Returns
 |      -------
 |      results : list or array of lists
 |          If `x` is a single point, returns a list of the indices of the
 |          neighbors of `x`. If `x` is an array of points, returns an object
 |          array of shape tuple containing lists of neighbors.
 |      
 |      Notes
 |      -----
 |      If you have many points whose neighbors you want to find, you may save
 |      substantial amounts of time by putting them in a cKDTree and using
 |      query_ball_tree.
 |      
 |      Examples
 |      --------
 |      >>> from scipy import spatial
 |      >>> x, y = np.mgrid[0:4, 0:4]
 |      >>> points = np.c_[x.ravel(), y.ravel()]
 |      >>> tree = spatial.cKDTree(points)
 |      >>> tree.query_ball_point([2, 0], 1)
 |      [4, 8, 9, 12]
 |  
 |  query_ball_tree(...)
 |      query_ball_tree(self, other, r, p=2., eps=0)
 |      
 |      Find all pairs of points whose distance is at most r
 |      
 |      Parameters
 |      ----------
 |      other : cKDTree instance
 |          The tree containing points to search against.
 |      r : float
 |          The maximum distance, has to be positive.
 |      p : float, optional
 |          Which Minkowski norm to use.  `p` has to meet the condition
 |          ``1 <= p <= infinity``.
 |      eps : float, optional
 |          Approximate search.  Branches of the tree are not explored
 |          if their nearest points are further than ``r/(1+eps)``, and
 |          branches are added in bulk if their furthest points are nearer
 |          than ``r * (1+eps)``.  `eps` has to be non-negative.
 |      
 |      Returns
 |      -------
 |      results : list of lists
 |          For each element ``self.data[i]`` of this tree, ``results[i]`` is a
 |          list of the indices of its neighbors in ``other.data``.
 |  
 |  query_pairs(...)
 |      query_pairs(self, r, p=2., eps=0)
 |      
 |      Find all pairs of points whose distance is at most r.
 |      
 |      Parameters
 |      ----------
 |      r : positive float
 |          The maximum distance.
 |      p : float, optional
 |          Which Minkowski norm to use.  ``p`` has to meet the condition
 |          ``1 <= p <= infinity``.
 |      eps : float, optional
 |          Approximate search.  Branches of the tree are not explored
 |          if their nearest points are further than ``r/(1+eps)``, and
 |          branches are added in bulk if their furthest points are nearer
 |          than ``r * (1+eps)``.  `eps` has to be non-negative.
 |      output_type : string, optional
 |          Choose the output container, 'set' or 'ndarray'. Default: 'set'
 |      
 |      Returns
 |      -------
 |      results : set or ndarray
 |          Set of pairs ``(i,j)``, with ``i < j``, for which the corresponding
 |          positions are close. If output_type is 'ndarray', an ndarry is 
 |          returned instead of a set.
 |  
 |  sparse_distance_matrix(...)
 |      sparse_distance_matrix(self, other, max_distance, p=2.)
 |      
 |      Compute a sparse distance matrix
 |      
 |      Computes a distance matrix between two cKDTrees, leaving as zero
 |      any distance greater than max_distance.
 |      
 |      Parameters
 |      ----------
 |      other : cKDTree
 |      
 |      max_distance : positive float
 |      
 |      p : float, 1<=p<=infinity
 |          Which Minkowski p-norm to use. 
 |      
 |      output_type : string, optional
 |          Which container to use for output data. Options: 'dok_matrix',
 |          'coo_matrix', 'dict', or 'ndarray'. Default: 'dok_matrix'.
 |      
 |      Returns
 |      -------
 |      result : dok_matrix, coo_matrix, dict or ndarray
 |          Sparse matrix representing the results in ""dictionary of keys"" 
 |          format. If a dict is returned the keys are (i,j) tuples of indices.
 |          If output_type is 'ndarray' a record array with fields 'i', 'j',
 |          and 'k' is returned,
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  boxsize
 |  
 |  data
 |  
 |  indices
 |  
 |  leafsize
 |  
 |  m
 |  
 |  maxes
 |  
 |  mins
 |  
 |  n
 |  
 |  size
 |  
 |  tree
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __pyx_vtable__ = <capsule object NULL>
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.interpolate.ndgriddata.griddata,interpolate.ndgriddata,griddata,"Python Library Documentation: function griddata in module scipy.interpolate.ndgriddata

griddata(points, values, xi, method='linear', fill_value=nan, rescale=False)
    Interpolate unstructured D-dimensional data.
    
    Parameters
    ----------
    points : ndarray of floats, shape (n, D)
        Data point coordinates. Can either be an array of
        shape (n, D), or a tuple of `ndim` arrays.
    values : ndarray of float or complex, shape (n,)
        Data values.
    xi : 2-D ndarray of float or tuple of 1-D array, shape (M, D)
        Points at which to interpolate data.
    method : {'linear', 'nearest', 'cubic'}, optional
        Method of interpolation. One of
    
        ``nearest``
          return the value at the data point closest to
          the point of interpolation.  See `NearestNDInterpolator` for
          more details.
    
        ``linear``
          tessellate the input point set to n-dimensional
          simplices, and interpolate linearly on each simplex.  See
          `LinearNDInterpolator` for more details.
    
        ``cubic`` (1-D)
          return the value determined from a cubic
          spline.
    
        ``cubic`` (2-D)
          return the value determined from a
          piecewise cubic, continuously differentiable (C1), and
          approximately curvature-minimizing polynomial surface. See
          `CloughTocher2DInterpolator` for more details.
    fill_value : float, optional
        Value used to fill in for requested points outside of the
        convex hull of the input points.  If not provided, then the
        default is ``nan``. This option has no effect for the
        'nearest' method.
    rescale : bool, optional
        Rescale points to unit cube before performing interpolation.
        This is useful if some of the input dimensions have
        incommensurable units and differ by many orders of magnitude.
    
        .. versionadded:: 0.14.0
        
    Returns
    -------
    ndarray
        Array of interpolated values.
    
    Notes
    -----
    
    .. versionadded:: 0.9
    
    Examples
    --------
    
    Suppose we want to interpolate the 2-D function
    
    >>> def func(x, y):
    ...     return x*(1-x)*np.cos(4*np.pi*x) * np.sin(4*np.pi*y**2)**2
    
    on a grid in [0, 1]x[0, 1]
    
    >>> grid_x, grid_y = np.mgrid[0:1:100j, 0:1:200j]
    
    but we only know its values at 1000 data points:
    
    >>> points = np.random.rand(1000, 2)
    >>> values = func(points[:,0], points[:,1])
    
    This can be done with `griddata` -- below we try out all of the
    interpolation methods:
    
    >>> from scipy.interpolate import griddata
    >>> grid_z0 = griddata(points, values, (grid_x, grid_y), method='nearest')
    >>> grid_z1 = griddata(points, values, (grid_x, grid_y), method='linear')
    >>> grid_z2 = griddata(points, values, (grid_x, grid_y), method='cubic')
    
    One can see that the exact result is reproduced by all of the
    methods to some degree, but for this smooth function the piecewise
    cubic interpolant gives the best results:
    
    >>> import matplotlib.pyplot as plt
    >>> plt.subplot(221)
    >>> plt.imshow(func(grid_x, grid_y).T, extent=(0,1,0,1), origin='lower')
    >>> plt.plot(points[:,0], points[:,1], 'k.', ms=1)
    >>> plt.title('Original')
    >>> plt.subplot(222)
    >>> plt.imshow(grid_z0.T, extent=(0,1,0,1), origin='lower')
    >>> plt.title('Nearest')
    >>> plt.subplot(223)
    >>> plt.imshow(grid_z1.T, extent=(0,1,0,1), origin='lower')
    >>> plt.title('Linear')
    >>> plt.subplot(224)
    >>> plt.imshow(grid_z2.T, extent=(0,1,0,1), origin='lower')
    >>> plt.title('Cubic')
    >>> plt.gcf().set_size_inches(6, 6)
    >>> plt.show()
",function,"(""(points, values, xi, method='linear', fill_value=nan, rescale=False)"",)",scipy,1.1.0,scipy.interpolate.ndgriddata.griddata,interpolate.ndgriddata,griddata,"Python Library Documentation: function griddata in module scipy.interpolate.ndgriddata

griddata(points, values, xi, method='linear', fill_value=nan, rescale=False)
    Interpolate unstructured D-dimensional data.
    
    Parameters
    ----------
    points : ndarray of floats, shape (n, D)
        Data point coordinates. Can either be an array of
        shape (n, D), or a tuple of `ndim` arrays.
    values : ndarray of float or complex, shape (n,)
        Data values.
    xi : 2-D ndarray of float or tuple of 1-D array, shape (M, D)
        Points at which to interpolate data.
    method : {'linear', 'nearest', 'cubic'}, optional
        Method of interpolation. One of
    
        ``nearest``
          return the value at the data point closest to
          the point of interpolation.  See `NearestNDInterpolator` for
          more details.
    
        ``linear``
          tessellate the input point set to n-dimensional
          simplices, and interpolate linearly on each simplex.  See
          `LinearNDInterpolator` for more details.
    
        ``cubic`` (1-D)
          return the value determined from a cubic
          spline.
    
        ``cubic`` (2-D)
          return the value determined from a
          piecewise cubic, continuously differentiable (C1), and
          approximately curvature-minimizing polynomial surface. See
          `CloughTocher2DInterpolator` for more details.
    fill_value : float, optional
        Value used to fill in for requested points outside of the
        convex hull of the input points.  If not provided, then the
        default is ``nan``. This option has no effect for the
        'nearest' method.
    rescale : bool, optional
        Rescale points to unit cube before performing interpolation.
        This is useful if some of the input dimensions have
        incommensurable units and differ by many orders of magnitude.
    
        .. versionadded:: 0.14.0
        
    Returns
    -------
    ndarray
        Array of interpolated values.
    
    Notes
    -----
    
    .. versionadded:: 0.9
    
    Examples
    --------
    
    Suppose we want to interpolate the 2-D function
    
    >>> def func(x, y):
    ...     return x*(1-x)*np.cos(4*np.pi*x) * np.sin(4*np.pi*y**2)**2
    
    on a grid in [0, 1]x[0, 1]
    
    >>> grid_x, grid_y = np.mgrid[0:1:100j, 0:1:200j]
    
    but we only know its values at 1000 data points:
    
    >>> points = np.random.rand(1000, 2)
    >>> values = func(points[:,0], points[:,1])
    
    This can be done with `griddata` -- below we try out all of the
    interpolation methods:
    
    >>> from scipy.interpolate import griddata
    >>> grid_z0 = griddata(points, values, (grid_x, grid_y), method='nearest')
    >>> grid_z1 = griddata(points, values, (grid_x, grid_y), method='linear')
    >>> grid_z2 = griddata(points, values, (grid_x, grid_y), method='cubic')
    
    One can see that the exact result is reproduced by all of the
    methods to some degree, but for this smooth function the piecewise
    cubic interpolant gives the best results:
    
    >>> import matplotlib.pyplot as plt
    >>> plt.subplot(221)
    >>> plt.imshow(func(grid_x, grid_y).T, extent=(0,1,0,1), origin='lower')
    >>> plt.plot(points[:,0], points[:,1], 'k.', ms=1)
    >>> plt.title('Original')
    >>> plt.subplot(222)
    >>> plt.imshow(grid_z0.T, extent=(0,1,0,1), origin='lower')
    >>> plt.title('Nearest')
    >>> plt.subplot(223)
    >>> plt.imshow(grid_z1.T, extent=(0,1,0,1), origin='lower')
    >>> plt.title('Linear')
    >>> plt.subplot(224)
    >>> plt.imshow(grid_z2.T, extent=(0,1,0,1), origin='lower')
    >>> plt.title('Cubic')
    >>> plt.gcf().set_size_inches(6, 6)
    >>> plt.show()
",function,"('points', 'values', 'xi', 'method', 'fill_value', 'rescale')","(nan, nan, nan, 'linear', nan, False)","(nan, nan, nan, 'str', nan, 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(points, values, xi, method='linear', fill_value=nan, rescale=False)"",)"
scipy,1.1.0,scipy.interpolate.polyint.BarycentricInterpolator,interpolate.polyint,BarycentricInterpolator,"Python Library Documentation: class BarycentricInterpolator in module scipy.interpolate.polyint

class BarycentricInterpolator(_Interpolator1D)
 |  The interpolating polynomial for a set of points
 |  
 |  Constructs a polynomial that passes through a given set of points.
 |  Allows evaluation of the polynomial, efficient changing of the y
 |  values to be interpolated, and updating by adding more x values.
 |  For reasons of numerical stability, this function does not compute
 |  the coefficients of the polynomial.
 |  
 |  The values yi need to be provided before the function is
 |  evaluated, but none of the preprocessing depends on them, so rapid
 |  updates are possible.
 |  
 |  Parameters
 |  ----------
 |  xi : array_like
 |      1-d array of x coordinates of the points the polynomial
 |      should pass through
 |  yi : array_like, optional
 |      The y coordinates of the points the polynomial should pass through.
 |      If None, the y values will be supplied later via the `set_y` method.
 |  axis : int, optional
 |      Axis in the yi array corresponding to the x-coordinate values.
 |  
 |  Notes
 |  -----
 |  This class uses a ""barycentric interpolation"" method that treats
 |  the problem as a special case of rational function interpolation.
 |  This algorithm is quite stable, numerically, but even in a world of
 |  exact computation, unless the x coordinates are chosen very
 |  carefully - Chebyshev zeros (e.g. cos(i*pi/n)) are a good choice -
 |  polynomial interpolation itself is a very ill-conditioned process
 |  due to the Runge phenomenon.
 |  
 |  Based on Berrut and Trefethen 2004, ""Barycentric Lagrange Interpolation"".
 |  
 |  Method resolution order:
 |      BarycentricInterpolator
 |      _Interpolator1D
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __call__(self, x)
 |      Evaluate the interpolating polynomial at the points x
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |      
 |      Notes
 |      -----
 |      Currently the code computes an outer product between x and the
 |      weights, that is, it constructs an intermediate array of size
 |      N by len(x), where N is the degree of the polynomial.
 |  
 |  __init__(self, xi, yi=None, axis=0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  add_xi(self, xi, yi=None)
 |      Add more x values to the set to be interpolated
 |      
 |      The barycentric interpolation algorithm allows easy updating by
 |      adding more points for the polynomial to pass through.
 |      
 |      Parameters
 |      ----------
 |      xi : array_like
 |          The x coordinates of the points that the polynomial should pass
 |          through.
 |      yi : array_like, optional
 |          The y coordinates of the points the polynomial should pass through.
 |          Should have shape ``(xi.size, R)``; if R > 1 then the polynomial is
 |          vector-valued.
 |          If `yi` is not given, the y values will be supplied later. `yi` should
 |          be given if and only if the interpolator has y values specified.
 |  
 |  set_yi(self, yi, axis=None)
 |      Update the y values to be interpolated
 |      
 |      The barycentric interpolation algorithm requires the calculation
 |      of weights, but these depend only on the xi. The yi can be changed
 |      at any time.
 |      
 |      Parameters
 |      ----------
 |      yi : array_like
 |          The y coordinates of the points the polynomial should pass through.
 |          If None, the y values will be supplied later.
 |      axis : int, optional
 |          Axis in the yi array corresponding to the x-coordinate values.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _Interpolator1D:
 |  
 |  dtype
",class,"('(self, xi, yi=None, axis=0)',)",scipy,1.1.0,scipy.interpolate.polyint.BarycentricInterpolator,interpolate.polyint,BarycentricInterpolator,"Python Library Documentation: class BarycentricInterpolator in module scipy.interpolate.polyint

class BarycentricInterpolator(_Interpolator1D)
 |  The interpolating polynomial for a set of points
 |  
 |  Constructs a polynomial that passes through a given set of points.
 |  Allows evaluation of the polynomial, efficient changing of the y
 |  values to be interpolated, and updating by adding more x values.
 |  For reasons of numerical stability, this function does not compute
 |  the coefficients of the polynomial.
 |  
 |  The values yi need to be provided before the function is
 |  evaluated, but none of the preprocessing depends on them, so rapid
 |  updates are possible.
 |  
 |  Parameters
 |  ----------
 |  xi : array_like
 |      1-d array of x coordinates of the points the polynomial
 |      should pass through
 |  yi : array_like, optional
 |      The y coordinates of the points the polynomial should pass through.
 |      If None, the y values will be supplied later via the `set_y` method.
 |  axis : int, optional
 |      Axis in the yi array corresponding to the x-coordinate values.
 |  
 |  Notes
 |  -----
 |  This class uses a ""barycentric interpolation"" method that treats
 |  the problem as a special case of rational function interpolation.
 |  This algorithm is quite stable, numerically, but even in a world of
 |  exact computation, unless the x coordinates are chosen very
 |  carefully - Chebyshev zeros (e.g. cos(i*pi/n)) are a good choice -
 |  polynomial interpolation itself is a very ill-conditioned process
 |  due to the Runge phenomenon.
 |  
 |  Based on Berrut and Trefethen 2004, ""Barycentric Lagrange Interpolation"".
 |  
 |  Method resolution order:
 |      BarycentricInterpolator
 |      _Interpolator1D
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __call__(self, x)
 |      Evaluate the interpolating polynomial at the points x
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |      
 |      Notes
 |      -----
 |      Currently the code computes an outer product between x and the
 |      weights, that is, it constructs an intermediate array of size
 |      N by len(x), where N is the degree of the polynomial.
 |  
 |  __init__(self, xi, yi=None, axis=0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  add_xi(self, xi, yi=None)
 |      Add more x values to the set to be interpolated
 |      
 |      The barycentric interpolation algorithm allows easy updating by
 |      adding more points for the polynomial to pass through.
 |      
 |      Parameters
 |      ----------
 |      xi : array_like
 |          The x coordinates of the points that the polynomial should pass
 |          through.
 |      yi : array_like, optional
 |          The y coordinates of the points the polynomial should pass through.
 |          Should have shape ``(xi.size, R)``; if R > 1 then the polynomial is
 |          vector-valued.
 |          If `yi` is not given, the y values will be supplied later. `yi` should
 |          be given if and only if the interpolator has y values specified.
 |  
 |  set_yi(self, yi, axis=None)
 |      Update the y values to be interpolated
 |      
 |      The barycentric interpolation algorithm requires the calculation
 |      of weights, but these depend only on the xi. The yi can be changed
 |      at any time.
 |      
 |      Parameters
 |      ----------
 |      yi : array_like
 |          The y coordinates of the points the polynomial should pass through.
 |          If None, the y values will be supplied later.
 |      axis : int, optional
 |          Axis in the yi array corresponding to the x-coordinate values.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _Interpolator1D:
 |  
 |  dtype
",class,"('self', 'xi', 'yi', 'axis')","(nan, nan, None, 0)","(nan, nan, 'NoneType', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, xi, yi=None, axis=0)',)"
scipy,1.1.0,scipy.interpolate.polyint.KroghInterpolator,interpolate.polyint,KroghInterpolator,"Python Library Documentation: class KroghInterpolator in module scipy.interpolate.polyint

class KroghInterpolator(_Interpolator1DWithDerivatives)
 |  Interpolating polynomial for a set of points.
 |  
 |  The polynomial passes through all the pairs (xi,yi). One may
 |  additionally specify a number of derivatives at each point xi;
 |  this is done by repeating the value xi and specifying the
 |  derivatives as successive yi values.
 |  
 |  Allows evaluation of the polynomial and all its derivatives.
 |  For reasons of numerical stability, this function does not compute
 |  the coefficients of the polynomial, although they can be obtained
 |  by evaluating all the derivatives.
 |  
 |  Parameters
 |  ----------
 |  xi : array_like, length N
 |      Known x-coordinates. Must be sorted in increasing order.
 |  yi : array_like
 |      Known y-coordinates. When an xi occurs two or more times in
 |      a row, the corresponding yi's represent derivative values.
 |  axis : int, optional
 |      Axis in the yi array corresponding to the x-coordinate values.
 |  
 |  Notes
 |  -----
 |  Be aware that the algorithms implemented here are not necessarily
 |  the most numerically stable known. Moreover, even in a world of
 |  exact computation, unless the x coordinates are chosen very
 |  carefully - Chebyshev zeros (e.g. cos(i*pi/n)) are a good choice -
 |  polynomial interpolation itself is a very ill-conditioned process
 |  due to the Runge phenomenon. In general, even with well-chosen
 |  x values, degrees higher than about thirty cause problems with
 |  numerical instability in this code.
 |  
 |  Based on [1]_.
 |  
 |  References
 |  ----------
 |  .. [1] Krogh, ""Efficient Algorithms for Polynomial Interpolation
 |      and Numerical Differentiation"", 1970.
 |  
 |  Examples
 |  --------
 |  To produce a polynomial that is zero at 0 and 1 and has
 |  derivative 2 at 0, call
 |  
 |  >>> from scipy.interpolate import KroghInterpolator
 |  >>> KroghInterpolator([0,0,1],[0,2,0])
 |  
 |  This constructs the quadratic 2*X**2-2*X. The derivative condition
 |  is indicated by the repeated zero in the xi array; the corresponding
 |  yi values are 0, the function value, and 2, the derivative value.
 |  
 |  For another example, given xi, yi, and a derivative ypi for each
 |  point, appropriate arrays can be constructed as:
 |  
 |  >>> xi = np.linspace(0, 1, 5)
 |  >>> yi, ypi = np.random.rand(2, 5)
 |  >>> xi_k, yi_k = np.repeat(xi, 2), np.ravel(np.dstack((yi,ypi)))
 |  >>> KroghInterpolator(xi_k, yi_k)
 |  
 |  To produce a vector-valued polynomial, supply a higher-dimensional
 |  array for yi:
 |  
 |  >>> KroghInterpolator([0,1],[[2,3],[4,5]])
 |  
 |  This constructs a linear polynomial giving (2,3) at 0 and (4,5) at 1.
 |  
 |  Method resolution order:
 |      KroghInterpolator
 |      _Interpolator1DWithDerivatives
 |      _Interpolator1D
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, xi, yi, axis=0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _Interpolator1DWithDerivatives:
 |  
 |  derivative(self, x, der=1)
 |      Evaluate one derivative of the polynomial at the point x
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Point or points at which to evaluate the derivatives
 |      
 |      der : integer, optional
 |          Which derivative to extract. This number includes the
 |          function value as 0th derivative.
 |      
 |      Returns
 |      -------
 |      d : ndarray
 |          Derivative interpolated at the x-points.  Shape of d is
 |          determined by replacing the interpolation axis in the
 |          original array with the shape of x.
 |      
 |      Notes
 |      -----
 |      This is computed by evaluating all derivatives up to the desired
 |      one (using self.derivatives()) and then discarding the rest.
 |  
 |  derivatives(self, x, der=None)
 |      Evaluate many derivatives of the polynomial at the point x
 |      
 |      Produce an array of all derivative values at the point x.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Point or points at which to evaluate the derivatives
 |      der : int or None, optional
 |          How many derivatives to extract; None for all potentially
 |          nonzero derivatives (that is a number equal to the number
 |          of points). This number includes the function value as 0th
 |          derivative.
 |      
 |      Returns
 |      -------
 |      d : ndarray
 |          Array with derivatives; d[j] contains the j-th derivative.
 |          Shape of d[j] is determined by replacing the interpolation
 |          axis in the original array with the shape of x.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.interpolate import KroghInterpolator
 |      >>> KroghInterpolator([0,0,0],[1,2,3]).derivatives(0)
 |      array([1.0,2.0,3.0])
 |      >>> KroghInterpolator([0,0,0],[1,2,3]).derivatives([0,0])
 |      array([[1.0,1.0],
 |             [2.0,2.0],
 |             [3.0,3.0]])
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _Interpolator1DWithDerivatives:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _Interpolator1D:
 |  
 |  __call__(self, x)
 |      Evaluate the interpolant
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _Interpolator1D:
 |  
 |  dtype
",class,"('(self, xi, yi, axis=0)',)",scipy,1.1.0,scipy.interpolate.polyint.KroghInterpolator,interpolate.polyint,KroghInterpolator,"Python Library Documentation: class KroghInterpolator in module scipy.interpolate.polyint

class KroghInterpolator(_Interpolator1DWithDerivatives)
 |  Interpolating polynomial for a set of points.
 |  
 |  The polynomial passes through all the pairs (xi,yi). One may
 |  additionally specify a number of derivatives at each point xi;
 |  this is done by repeating the value xi and specifying the
 |  derivatives as successive yi values.
 |  
 |  Allows evaluation of the polynomial and all its derivatives.
 |  For reasons of numerical stability, this function does not compute
 |  the coefficients of the polynomial, although they can be obtained
 |  by evaluating all the derivatives.
 |  
 |  Parameters
 |  ----------
 |  xi : array_like, length N
 |      Known x-coordinates. Must be sorted in increasing order.
 |  yi : array_like
 |      Known y-coordinates. When an xi occurs two or more times in
 |      a row, the corresponding yi's represent derivative values.
 |  axis : int, optional
 |      Axis in the yi array corresponding to the x-coordinate values.
 |  
 |  Notes
 |  -----
 |  Be aware that the algorithms implemented here are not necessarily
 |  the most numerically stable known. Moreover, even in a world of
 |  exact computation, unless the x coordinates are chosen very
 |  carefully - Chebyshev zeros (e.g. cos(i*pi/n)) are a good choice -
 |  polynomial interpolation itself is a very ill-conditioned process
 |  due to the Runge phenomenon. In general, even with well-chosen
 |  x values, degrees higher than about thirty cause problems with
 |  numerical instability in this code.
 |  
 |  Based on [1]_.
 |  
 |  References
 |  ----------
 |  .. [1] Krogh, ""Efficient Algorithms for Polynomial Interpolation
 |      and Numerical Differentiation"", 1970.
 |  
 |  Examples
 |  --------
 |  To produce a polynomial that is zero at 0 and 1 and has
 |  derivative 2 at 0, call
 |  
 |  >>> from scipy.interpolate import KroghInterpolator
 |  >>> KroghInterpolator([0,0,1],[0,2,0])
 |  
 |  This constructs the quadratic 2*X**2-2*X. The derivative condition
 |  is indicated by the repeated zero in the xi array; the corresponding
 |  yi values are 0, the function value, and 2, the derivative value.
 |  
 |  For another example, given xi, yi, and a derivative ypi for each
 |  point, appropriate arrays can be constructed as:
 |  
 |  >>> xi = np.linspace(0, 1, 5)
 |  >>> yi, ypi = np.random.rand(2, 5)
 |  >>> xi_k, yi_k = np.repeat(xi, 2), np.ravel(np.dstack((yi,ypi)))
 |  >>> KroghInterpolator(xi_k, yi_k)
 |  
 |  To produce a vector-valued polynomial, supply a higher-dimensional
 |  array for yi:
 |  
 |  >>> KroghInterpolator([0,1],[[2,3],[4,5]])
 |  
 |  This constructs a linear polynomial giving (2,3) at 0 and (4,5) at 1.
 |  
 |  Method resolution order:
 |      KroghInterpolator
 |      _Interpolator1DWithDerivatives
 |      _Interpolator1D
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, xi, yi, axis=0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _Interpolator1DWithDerivatives:
 |  
 |  derivative(self, x, der=1)
 |      Evaluate one derivative of the polynomial at the point x
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Point or points at which to evaluate the derivatives
 |      
 |      der : integer, optional
 |          Which derivative to extract. This number includes the
 |          function value as 0th derivative.
 |      
 |      Returns
 |      -------
 |      d : ndarray
 |          Derivative interpolated at the x-points.  Shape of d is
 |          determined by replacing the interpolation axis in the
 |          original array with the shape of x.
 |      
 |      Notes
 |      -----
 |      This is computed by evaluating all derivatives up to the desired
 |      one (using self.derivatives()) and then discarding the rest.
 |  
 |  derivatives(self, x, der=None)
 |      Evaluate many derivatives of the polynomial at the point x
 |      
 |      Produce an array of all derivative values at the point x.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Point or points at which to evaluate the derivatives
 |      der : int or None, optional
 |          How many derivatives to extract; None for all potentially
 |          nonzero derivatives (that is a number equal to the number
 |          of points). This number includes the function value as 0th
 |          derivative.
 |      
 |      Returns
 |      -------
 |      d : ndarray
 |          Array with derivatives; d[j] contains the j-th derivative.
 |          Shape of d[j] is determined by replacing the interpolation
 |          axis in the original array with the shape of x.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.interpolate import KroghInterpolator
 |      >>> KroghInterpolator([0,0,0],[1,2,3]).derivatives(0)
 |      array([1.0,2.0,3.0])
 |      >>> KroghInterpolator([0,0,0],[1,2,3]).derivatives([0,0])
 |      array([[1.0,1.0],
 |             [2.0,2.0],
 |             [3.0,3.0]])
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _Interpolator1DWithDerivatives:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _Interpolator1D:
 |  
 |  __call__(self, x)
 |      Evaluate the interpolant
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _Interpolator1D:
 |  
 |  dtype
",class,"('self', 'xi', 'yi', 'axis')","(nan, nan, nan, 0)","(nan, nan, nan, 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, xi, yi, axis=0)',)"
scipy,1.1.0,scipy.interpolate.polyint._Interpolator1D,interpolate.polyint,_Interpolator1D,"Python Library Documentation: class _Interpolator1D in module scipy.interpolate.polyint

class _Interpolator1D(builtins.object)
 |  Common features in univariate interpolation
 |  
 |  Deal with input data type and interpolation axis rolling.  The
 |  actual interpolator can assume the y-data is of shape (n, r) where
 |  `n` is the number of x-points, and `r` the number of variables,
 |  and use self.dtype as the y-data type.
 |  
 |  Attributes
 |  ----------
 |  _y_axis
 |      Axis along which the interpolation goes in the original array
 |  _y_extra_shape
 |      Additional trailing shape of the input arrays, excluding
 |      the interpolation axis.
 |  dtype
 |      Dtype of the y-data arrays. Can be set via set_dtype, which
 |      forces it to be float or complex.
 |  
 |  Methods
 |  -------
 |  __call__
 |  _prepare_x
 |  _finish_y
 |  _reshape_yi
 |  _set_yi
 |  _set_dtype
 |  _evaluate
 |  
 |  Methods defined here:
 |  
 |  __call__(self, x)
 |      Evaluate the interpolant
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |  
 |  __init__(self, xi=None, yi=None, axis=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  dtype
",class,"('(self, xi=None, yi=None, axis=None)',)",scipy,1.1.0,scipy.interpolate.polyint._Interpolator1D,interpolate.polyint,_Interpolator1D,"Python Library Documentation: class _Interpolator1D in module scipy.interpolate.polyint

class _Interpolator1D(builtins.object)
 |  Common features in univariate interpolation
 |  
 |  Deal with input data type and interpolation axis rolling.  The
 |  actual interpolator can assume the y-data is of shape (n, r) where
 |  `n` is the number of x-points, and `r` the number of variables,
 |  and use self.dtype as the y-data type.
 |  
 |  Attributes
 |  ----------
 |  _y_axis
 |      Axis along which the interpolation goes in the original array
 |  _y_extra_shape
 |      Additional trailing shape of the input arrays, excluding
 |      the interpolation axis.
 |  dtype
 |      Dtype of the y-data arrays. Can be set via set_dtype, which
 |      forces it to be float or complex.
 |  
 |  Methods
 |  -------
 |  __call__
 |  _prepare_x
 |  _finish_y
 |  _reshape_yi
 |  _set_yi
 |  _set_dtype
 |  _evaluate
 |  
 |  Methods defined here:
 |  
 |  __call__(self, x)
 |      Evaluate the interpolant
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |  
 |  __init__(self, xi=None, yi=None, axis=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  dtype
",class,"('self', 'xi', 'yi', 'axis')","(nan, None, None, None)","(nan, 'NoneType', 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, xi=None, yi=None, axis=None)',)"
scipy,1.1.0,scipy.interpolate.polyint._Interpolator1DWithDerivatives,interpolate.polyint,_Interpolator1DWithDerivatives,"Python Library Documentation: class _Interpolator1DWithDerivatives in module scipy.interpolate.polyint

class _Interpolator1DWithDerivatives(_Interpolator1D)
 |  Common features in univariate interpolation
 |  
 |  Deal with input data type and interpolation axis rolling.  The
 |  actual interpolator can assume the y-data is of shape (n, r) where
 |  `n` is the number of x-points, and `r` the number of variables,
 |  and use self.dtype as the y-data type.
 |  
 |  Attributes
 |  ----------
 |  _y_axis
 |      Axis along which the interpolation goes in the original array
 |  _y_extra_shape
 |      Additional trailing shape of the input arrays, excluding
 |      the interpolation axis.
 |  dtype
 |      Dtype of the y-data arrays. Can be set via set_dtype, which
 |      forces it to be float or complex.
 |  
 |  Methods
 |  -------
 |  __call__
 |  _prepare_x
 |  _finish_y
 |  _reshape_yi
 |  _set_yi
 |  _set_dtype
 |  _evaluate
 |  
 |  Method resolution order:
 |      _Interpolator1DWithDerivatives
 |      _Interpolator1D
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  derivative(self, x, der=1)
 |      Evaluate one derivative of the polynomial at the point x
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Point or points at which to evaluate the derivatives
 |      
 |      der : integer, optional
 |          Which derivative to extract. This number includes the
 |          function value as 0th derivative.
 |      
 |      Returns
 |      -------
 |      d : ndarray
 |          Derivative interpolated at the x-points.  Shape of d is
 |          determined by replacing the interpolation axis in the
 |          original array with the shape of x.
 |      
 |      Notes
 |      -----
 |      This is computed by evaluating all derivatives up to the desired
 |      one (using self.derivatives()) and then discarding the rest.
 |  
 |  derivatives(self, x, der=None)
 |      Evaluate many derivatives of the polynomial at the point x
 |      
 |      Produce an array of all derivative values at the point x.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Point or points at which to evaluate the derivatives
 |      der : int or None, optional
 |          How many derivatives to extract; None for all potentially
 |          nonzero derivatives (that is a number equal to the number
 |          of points). This number includes the function value as 0th
 |          derivative.
 |      
 |      Returns
 |      -------
 |      d : ndarray
 |          Array with derivatives; d[j] contains the j-th derivative.
 |          Shape of d[j] is determined by replacing the interpolation
 |          axis in the original array with the shape of x.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.interpolate import KroghInterpolator
 |      >>> KroghInterpolator([0,0,0],[1,2,3]).derivatives(0)
 |      array([1.0,2.0,3.0])
 |      >>> KroghInterpolator([0,0,0],[1,2,3]).derivatives([0,0])
 |      array([[1.0,1.0],
 |             [2.0,2.0],
 |             [3.0,3.0]])
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _Interpolator1D:
 |  
 |  __call__(self, x)
 |      Evaluate the interpolant
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |  
 |  __init__(self, xi=None, yi=None, axis=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _Interpolator1D:
 |  
 |  dtype
",class,"('(self, xi=None, yi=None, axis=None)',)",scipy,1.1.0,scipy.interpolate.polyint._Interpolator1DWithDerivatives,interpolate.polyint,_Interpolator1DWithDerivatives,"Python Library Documentation: class _Interpolator1DWithDerivatives in module scipy.interpolate.polyint

class _Interpolator1DWithDerivatives(_Interpolator1D)
 |  Common features in univariate interpolation
 |  
 |  Deal with input data type and interpolation axis rolling.  The
 |  actual interpolator can assume the y-data is of shape (n, r) where
 |  `n` is the number of x-points, and `r` the number of variables,
 |  and use self.dtype as the y-data type.
 |  
 |  Attributes
 |  ----------
 |  _y_axis
 |      Axis along which the interpolation goes in the original array
 |  _y_extra_shape
 |      Additional trailing shape of the input arrays, excluding
 |      the interpolation axis.
 |  dtype
 |      Dtype of the y-data arrays. Can be set via set_dtype, which
 |      forces it to be float or complex.
 |  
 |  Methods
 |  -------
 |  __call__
 |  _prepare_x
 |  _finish_y
 |  _reshape_yi
 |  _set_yi
 |  _set_dtype
 |  _evaluate
 |  
 |  Method resolution order:
 |      _Interpolator1DWithDerivatives
 |      _Interpolator1D
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  derivative(self, x, der=1)
 |      Evaluate one derivative of the polynomial at the point x
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Point or points at which to evaluate the derivatives
 |      
 |      der : integer, optional
 |          Which derivative to extract. This number includes the
 |          function value as 0th derivative.
 |      
 |      Returns
 |      -------
 |      d : ndarray
 |          Derivative interpolated at the x-points.  Shape of d is
 |          determined by replacing the interpolation axis in the
 |          original array with the shape of x.
 |      
 |      Notes
 |      -----
 |      This is computed by evaluating all derivatives up to the desired
 |      one (using self.derivatives()) and then discarding the rest.
 |  
 |  derivatives(self, x, der=None)
 |      Evaluate many derivatives of the polynomial at the point x
 |      
 |      Produce an array of all derivative values at the point x.
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Point or points at which to evaluate the derivatives
 |      der : int or None, optional
 |          How many derivatives to extract; None for all potentially
 |          nonzero derivatives (that is a number equal to the number
 |          of points). This number includes the function value as 0th
 |          derivative.
 |      
 |      Returns
 |      -------
 |      d : ndarray
 |          Array with derivatives; d[j] contains the j-th derivative.
 |          Shape of d[j] is determined by replacing the interpolation
 |          axis in the original array with the shape of x.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.interpolate import KroghInterpolator
 |      >>> KroghInterpolator([0,0,0],[1,2,3]).derivatives(0)
 |      array([1.0,2.0,3.0])
 |      >>> KroghInterpolator([0,0,0],[1,2,3]).derivatives([0,0])
 |      array([[1.0,1.0],
 |             [2.0,2.0],
 |             [3.0,3.0]])
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _Interpolator1D:
 |  
 |  __call__(self, x)
 |      Evaluate the interpolant
 |      
 |      Parameters
 |      ----------
 |      x : array_like
 |          Points to evaluate the interpolant at.
 |      
 |      Returns
 |      -------
 |      y : array_like
 |          Interpolated values. Shape is determined by replacing
 |          the interpolation axis in the original array with the shape of x.
 |  
 |  __init__(self, xi=None, yi=None, axis=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _Interpolator1D:
 |  
 |  dtype
",class,"('self', 'xi', 'yi', 'axis')","(nan, None, None, None)","(nan, 'NoneType', 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, xi=None, yi=None, axis=None)',)"
scipy,1.1.0,scipy.interpolate.polyint._asarray_validated,interpolate.polyint,_asarray_validated,"Python Library Documentation: function _asarray_validated in module scipy._lib._util

_asarray_validated(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)
    Helper function for scipy argument validation.
    
    Many scipy linear algebra functions do support arbitrary array-like
    input arguments.  Examples of commonly unsupported inputs include
    matrices containing inf/nan, sparse matrix representations, and
    matrices with complicated elements.
    
    Parameters
    ----------
    a : array_like
        The array-like input.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default: True
    sparse_ok : bool, optional
        True if scipy sparse matrices are allowed.
    objects_ok : bool, optional
        True if arrays with dype('O') are allowed.
    mask_ok : bool, optional
        True if masked arrays are allowed.
    as_inexact : bool, optional
        True to convert the input array to a np.inexact dtype.
    
    Returns
    -------
    ret : ndarray
        The converted validated array.
",function,"('(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)',)",scipy,1.1.0,scipy.interpolate.polyint._asarray_validated,interpolate.polyint,_asarray_validated,"Python Library Documentation: function _asarray_validated in module scipy._lib._util

_asarray_validated(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)
    Helper function for scipy argument validation.
    
    Many scipy linear algebra functions do support arbitrary array-like
    input arguments.  Examples of commonly unsupported inputs include
    matrices containing inf/nan, sparse matrix representations, and
    matrices with complicated elements.
    
    Parameters
    ----------
    a : array_like
        The array-like input.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default: True
    sparse_ok : bool, optional
        True if scipy sparse matrices are allowed.
    objects_ok : bool, optional
        True if arrays with dype('O') are allowed.
    mask_ok : bool, optional
        True if masked arrays are allowed.
    as_inexact : bool, optional
        True to convert the input array to a np.inexact dtype.
    
    Returns
    -------
    ret : ndarray
        The converted validated array.
",function,"('a', 'check_finite', 'sparse_ok', 'objects_ok', 'mask_ok', 'as_inexact')","(nan, True, False, False, False, False)","(nan, 'bool', 'bool', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)',)"
scipy,1.1.0,scipy.interpolate.polyint._isscalar,interpolate.polyint,_isscalar,"Python Library Documentation: function _isscalar in module scipy.interpolate.polyint

_isscalar(x)
    Check whether x is if a scalar type, or 0-dim
",function,"('(x)',)",scipy,1.1.0,scipy.interpolate.polyint._isscalar,interpolate.polyint,_isscalar,"Python Library Documentation: function _isscalar in module scipy.interpolate.polyint

_isscalar(x)
    Check whether x is if a scalar type, or 0-dim
",function,"('x',)","(nan,)","(nan,)","('arg_info',)","('(x)',)"
scipy,1.1.0,scipy.interpolate.polyint.approximate_taylor_polynomial,interpolate.polyint,approximate_taylor_polynomial,"Python Library Documentation: function approximate_taylor_polynomial in module scipy.interpolate.polyint

approximate_taylor_polynomial(f, x, degree, scale, order=None)
    Estimate the Taylor polynomial of f at x by polynomial fitting.
    
    Parameters
    ----------
    f : callable
        The function whose Taylor polynomial is sought. Should accept
        a vector of `x` values.
    x : scalar
        The point at which the polynomial is to be evaluated.
    degree : int
        The degree of the Taylor polynomial
    scale : scalar
        The width of the interval to use to evaluate the Taylor polynomial.
        Function values spread over a range this wide are used to fit the
        polynomial. Must be chosen carefully.
    order : int or None, optional
        The order of the polynomial to be used in the fitting; `f` will be
        evaluated ``order+1`` times. If None, use `degree`.
    
    Returns
    -------
    p : poly1d instance
        The Taylor polynomial (translated to the origin, so that
        for example p(0)=f(x)).
    
    Notes
    -----
    The appropriate choice of ""scale"" is a trade-off; too large and the
    function differs from its Taylor polynomial too much to get a good
    answer, too small and round-off errors overwhelm the higher-order terms.
    The algorithm used becomes numerically unstable around order 30 even
    under ideal circumstances.
    
    Choosing order somewhat larger than degree may improve the higher-order
    terms.
",function,"('(f, x, degree, scale, order=None)',)",scipy,1.1.0,scipy.interpolate.polyint.approximate_taylor_polynomial,interpolate.polyint,approximate_taylor_polynomial,"Python Library Documentation: function approximate_taylor_polynomial in module scipy.interpolate.polyint

approximate_taylor_polynomial(f, x, degree, scale, order=None)
    Estimate the Taylor polynomial of f at x by polynomial fitting.
    
    Parameters
    ----------
    f : callable
        The function whose Taylor polynomial is sought. Should accept
        a vector of `x` values.
    x : scalar
        The point at which the polynomial is to be evaluated.
    degree : int
        The degree of the Taylor polynomial
    scale : scalar
        The width of the interval to use to evaluate the Taylor polynomial.
        Function values spread over a range this wide are used to fit the
        polynomial. Must be chosen carefully.
    order : int or None, optional
        The order of the polynomial to be used in the fitting; `f` will be
        evaluated ``order+1`` times. If None, use `degree`.
    
    Returns
    -------
    p : poly1d instance
        The Taylor polynomial (translated to the origin, so that
        for example p(0)=f(x)).
    
    Notes
    -----
    The appropriate choice of ""scale"" is a trade-off; too large and the
    function differs from its Taylor polynomial too much to get a good
    answer, too small and round-off errors overwhelm the higher-order terms.
    The algorithm used becomes numerically unstable around order 30 even
    under ideal circumstances.
    
    Choosing order somewhat larger than degree may improve the higher-order
    terms.
",function,"('f', 'x', 'degree', 'scale', 'order')","(nan, nan, nan, nan, None)","(nan, nan, nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(f, x, degree, scale, order=None)',)"
scipy,1.1.0,scipy.interpolate.polyint.barycentric_interpolate,interpolate.polyint,barycentric_interpolate,"Python Library Documentation: function barycentric_interpolate in module scipy.interpolate.polyint

barycentric_interpolate(xi, yi, x, axis=0)
    Convenience function for polynomial interpolation.
    
    Constructs a polynomial that passes through a given set of points,
    then evaluates the polynomial. For reasons of numerical stability,
    this function does not compute the coefficients of the polynomial.
    
    This function uses a ""barycentric interpolation"" method that treats
    the problem as a special case of rational function interpolation.
    This algorithm is quite stable, numerically, but even in a world of
    exact computation, unless the `x` coordinates are chosen very
    carefully - Chebyshev zeros (e.g. cos(i*pi/n)) are a good choice -
    polynomial interpolation itself is a very ill-conditioned process
    due to the Runge phenomenon.
    
    Parameters
    ----------
    xi : array_like
        1-d array of x coordinates of the points the polynomial should
        pass through
    yi : array_like
        The y coordinates of the points the polynomial should pass through.
    x : scalar or array_like
        Points to evaluate the interpolator at.
    axis : int, optional
        Axis in the yi array corresponding to the x-coordinate values.
    
    Returns
    -------
    y : scalar or array_like
        Interpolated values. Shape is determined by replacing
        the interpolation axis in the original array with the shape of x.
    
    See Also
    --------
    BarycentricInterpolator
    
    Notes
    -----
    Construction of the interpolation weights is a relatively slow process.
    If you want to call this many times with the same xi (but possibly
    varying yi or x) you should use the class `BarycentricInterpolator`.
    This is what this function uses internally.
",function,"('(xi, yi, x, axis=0)',)",scipy,1.1.0,scipy.interpolate.polyint.barycentric_interpolate,interpolate.polyint,barycentric_interpolate,"Python Library Documentation: function barycentric_interpolate in module scipy.interpolate.polyint

barycentric_interpolate(xi, yi, x, axis=0)
    Convenience function for polynomial interpolation.
    
    Constructs a polynomial that passes through a given set of points,
    then evaluates the polynomial. For reasons of numerical stability,
    this function does not compute the coefficients of the polynomial.
    
    This function uses a ""barycentric interpolation"" method that treats
    the problem as a special case of rational function interpolation.
    This algorithm is quite stable, numerically, but even in a world of
    exact computation, unless the `x` coordinates are chosen very
    carefully - Chebyshev zeros (e.g. cos(i*pi/n)) are a good choice -
    polynomial interpolation itself is a very ill-conditioned process
    due to the Runge phenomenon.
    
    Parameters
    ----------
    xi : array_like
        1-d array of x coordinates of the points the polynomial should
        pass through
    yi : array_like
        The y coordinates of the points the polynomial should pass through.
    x : scalar or array_like
        Points to evaluate the interpolator at.
    axis : int, optional
        Axis in the yi array corresponding to the x-coordinate values.
    
    Returns
    -------
    y : scalar or array_like
        Interpolated values. Shape is determined by replacing
        the interpolation axis in the original array with the shape of x.
    
    See Also
    --------
    BarycentricInterpolator
    
    Notes
    -----
    Construction of the interpolation weights is a relatively slow process.
    If you want to call this many times with the same xi (but possibly
    varying yi or x) you should use the class `BarycentricInterpolator`.
    This is what this function uses internally.
",function,"('xi', 'yi', 'x', 'axis')","(nan, nan, nan, 0)","(nan, nan, nan, 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(xi, yi, x, axis=0)',)"
scipy,1.1.0,scipy.interpolate.polyint.factorial,interpolate.polyint,factorial,"Python Library Documentation: function factorial in module scipy.special.basic

factorial(n, exact=False)
    The factorial of a number or array of numbers.
    
    The factorial of non-negative integer `n` is the product of all
    positive integers less than or equal to `n`::
    
        n! = n * (n - 1) * (n - 2) * ... * 1
    
    Parameters
    ----------
    n : int or array_like of ints
        Input values.  If ``n < 0``, the return value is 0.
    exact : bool, optional
        If True, calculate the answer exactly using long integer arithmetic.
        If False, result is approximated in floating point rapidly using the
        `gamma` function.
        Default is False.
    
    Returns
    -------
    nf : float or int or ndarray
        Factorial of `n`, as integer or float depending on `exact`.
    
    Notes
    -----
    For arrays with ``exact=True``, the factorial is computed only once, for
    the largest input, with each other result computed in the process.
    The output dtype is increased to ``int64`` or ``object`` if necessary.
    
    With ``exact=False`` the factorial is approximated using the gamma
    function:
    
    .. math:: n! = \Gamma(n+1)
    
    Examples
    --------
    >>> from scipy.special import factorial
    >>> arr = np.array([3, 4, 5])
    >>> factorial(arr, exact=False)
    array([   6.,   24.,  120.])
    >>> factorial(arr, exact=True)
    array([  6,  24, 120])
    >>> factorial(5, exact=True)
    120L
",function,"('(n, exact=False)',)",scipy,1.1.0,scipy.interpolate.polyint.factorial,interpolate.polyint,factorial,"Python Library Documentation: function factorial in module scipy.special.basic

factorial(n, exact=False)
    The factorial of a number or array of numbers.
    
    The factorial of non-negative integer `n` is the product of all
    positive integers less than or equal to `n`::
    
        n! = n * (n - 1) * (n - 2) * ... * 1
    
    Parameters
    ----------
    n : int or array_like of ints
        Input values.  If ``n < 0``, the return value is 0.
    exact : bool, optional
        If True, calculate the answer exactly using long integer arithmetic.
        If False, result is approximated in floating point rapidly using the
        `gamma` function.
        Default is False.
    
    Returns
    -------
    nf : float or int or ndarray
        Factorial of `n`, as integer or float depending on `exact`.
    
    Notes
    -----
    For arrays with ``exact=True``, the factorial is computed only once, for
    the largest input, with each other result computed in the process.
    The output dtype is increased to ``int64`` or ``object`` if necessary.
    
    With ``exact=False`` the factorial is approximated using the gamma
    function:
    
    .. math:: n! = \Gamma(n+1)
    
    Examples
    --------
    >>> from scipy.special import factorial
    >>> arr = np.array([3, 4, 5])
    >>> factorial(arr, exact=False)
    array([   6.,   24.,  120.])
    >>> factorial(arr, exact=True)
    array([  6,  24, 120])
    >>> factorial(5, exact=True)
    120L
",function,"('n', 'exact')","(nan, False)","(nan, 'bool')","('arg_info', 'arg_info')","('(n, exact=False)',)"
scipy,1.1.0,scipy.interpolate.polyint.krogh_interpolate,interpolate.polyint,krogh_interpolate,"Python Library Documentation: function krogh_interpolate in module scipy.interpolate.polyint

krogh_interpolate(xi, yi, x, der=0, axis=0)
    Convenience function for polynomial interpolation.
    
    See `KroghInterpolator` for more details.
    
    Parameters
    ----------
    xi : array_like
        Known x-coordinates.
    yi : array_like
        Known y-coordinates, of shape ``(xi.size, R)``.  Interpreted as
        vectors of length R, or scalars if R=1.
    x : array_like
        Point or points at which to evaluate the derivatives.
    der : int or list, optional
        How many derivatives to extract; None for all potentially
        nonzero derivatives (that is a number equal to the number
        of points), or a list of derivatives to extract. This number
        includes the function value as 0th derivative.
    axis : int, optional
        Axis in the yi array corresponding to the x-coordinate values.
    
    Returns
    -------
    d : ndarray
        If the interpolator's values are R-dimensional then the
        returned array will be the number of derivatives by N by R.
        If `x` is a scalar, the middle dimension will be dropped; if
        the `yi` are scalars then the last dimension will be dropped.
    
    See Also
    --------
    KroghInterpolator
    
    Notes
    -----
    Construction of the interpolating polynomial is a relatively expensive
    process. If you want to evaluate it repeatedly consider using the class
    KroghInterpolator (which is what this function uses).
",function,"('(xi, yi, x, der=0, axis=0)',)",scipy,1.1.0,scipy.interpolate.polyint.krogh_interpolate,interpolate.polyint,krogh_interpolate,"Python Library Documentation: function krogh_interpolate in module scipy.interpolate.polyint

krogh_interpolate(xi, yi, x, der=0, axis=0)
    Convenience function for polynomial interpolation.
    
    See `KroghInterpolator` for more details.
    
    Parameters
    ----------
    xi : array_like
        Known x-coordinates.
    yi : array_like
        Known y-coordinates, of shape ``(xi.size, R)``.  Interpreted as
        vectors of length R, or scalars if R=1.
    x : array_like
        Point or points at which to evaluate the derivatives.
    der : int or list, optional
        How many derivatives to extract; None for all potentially
        nonzero derivatives (that is a number equal to the number
        of points), or a list of derivatives to extract. This number
        includes the function value as 0th derivative.
    axis : int, optional
        Axis in the yi array corresponding to the x-coordinate values.
    
    Returns
    -------
    d : ndarray
        If the interpolator's values are R-dimensional then the
        returned array will be the number of derivatives by N by R.
        If `x` is a scalar, the middle dimension will be dropped; if
        the `yi` are scalars then the last dimension will be dropped.
    
    See Also
    --------
    KroghInterpolator
    
    Notes
    -----
    Construction of the interpolating polynomial is a relatively expensive
    process. If you want to evaluate it repeatedly consider using the class
    KroghInterpolator (which is what this function uses).
",function,"('xi', 'yi', 'x', 'der', 'axis')","(nan, nan, nan, 0, 0)","(nan, nan, nan, 'int', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(xi, yi, x, der=0, axis=0)',)"
scipy,1.1.0,scipy.interpolate.polyint.xrange,interpolate.polyint,range,"Python Library Documentation: class range in module builtins

class range(object)
 |  range(stop) -> range object
 |  range(start, stop[, step]) -> range object
 |  
 |  Return an object that produces a sequence of integers from start (inclusive)
 |  to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.
 |  start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.
 |  These are exactly the valid indices for a list of 4 elements.
 |  When step is given, it specifies the increment (or decrement).
 |  
 |  Methods defined here:
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(...)
 |      Return a reverse iterator.
 |  
 |  count(...)
 |      rangeobject.count(value) -> integer -- return number of occurrences of value
 |  
 |  index(...)
 |      rangeobject.index(value, [start, [stop]]) -> integer -- return index of value.
 |      Raise ValueError if the value is not present.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  start
 |  
 |  step
 |  
 |  stop
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.interpolate.polyint.xrange,interpolate.polyint,range,"Python Library Documentation: class range in module builtins

class range(object)
 |  range(stop) -> range object
 |  range(start, stop[, step]) -> range object
 |  
 |  Return an object that produces a sequence of integers from start (inclusive)
 |  to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.
 |  start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.
 |  These are exactly the valid indices for a list of 4 elements.
 |  When step is given, it specifies the increment (or decrement).
 |  
 |  Methods defined here:
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(...)
 |      Return a reverse iterator.
 |  
 |  count(...)
 |      rangeobject.count(value) -> integer -- return number of occurrences of value
 |  
 |  index(...)
 |      rangeobject.index(value, [start, [stop]]) -> integer -- return index of value.
 |      Raise ValueError if the value is not present.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  start
 |  
 |  step
 |  
 |  stop
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.interpolate.rbf.Rbf,interpolate.rbf,Rbf,"Python Library Documentation: class Rbf in module scipy.interpolate.rbf

class Rbf(builtins.object)
 |  Rbf(*args)
 |  
 |  A class for radial basis function approximation/interpolation of
 |  n-dimensional scattered data.
 |  
 |  Parameters
 |  ----------
 |  *args : arrays
 |      x, y, z, ..., d, where x, y, z, ... are the coordinates of the nodes
 |      and d is the array of values at the nodes
 |  function : str or callable, optional
 |      The radial basis function, based on the radius, r, given by the norm
 |      (default is Euclidean distance); the default is 'multiquadric'::
 |  
 |          'multiquadric': sqrt((r/self.epsilon)**2 + 1)
 |          'inverse': 1.0/sqrt((r/self.epsilon)**2 + 1)
 |          'gaussian': exp(-(r/self.epsilon)**2)
 |          'linear': r
 |          'cubic': r**3
 |          'quintic': r**5
 |          'thin_plate': r**2 * log(r)
 |  
 |      If callable, then it must take 2 arguments (self, r).  The epsilon
 |      parameter will be available as self.epsilon.  Other keyword
 |      arguments passed in will be available as well.
 |  
 |  epsilon : float, optional
 |      Adjustable constant for gaussian or multiquadrics functions
 |      - defaults to approximate average distance between nodes (which is
 |      a good start).
 |  smooth : float, optional
 |      Values greater than zero increase the smoothness of the
 |      approximation.  0 is for interpolation (default), the function will
 |      always go through the nodal points in this case.
 |  norm : callable, optional
 |      A function that returns the 'distance' between two points, with
 |      inputs as arrays of positions (x, y, z, ...), and an output as an
 |      array of distance.  E.g, the default::
 |  
 |          def euclidean_norm(x1, x2):
 |              return sqrt( ((x1 - x2)**2).sum(axis=0) )
 |  
 |      which is called with ``x1 = x1[ndims, newaxis, :]`` and
 |      ``x2 = x2[ndims, : ,newaxis]`` such that the result is a matrix of the
 |      distances from each point in ``x1`` to each point in ``x2``.
 |  
 |  Examples
 |  --------
 |  >>> from scipy.interpolate import Rbf
 |  >>> x, y, z, d = np.random.rand(4, 50)
 |  >>> rbfi = Rbf(x, y, z, d)  # radial basis function interpolator instance
 |  >>> xi = yi = zi = np.linspace(0, 1, 20)
 |  >>> di = rbfi(xi, yi, zi)   # interpolated values
 |  >>> di.shape
 |  (20,)
 |  
 |  Methods defined here:
 |  
 |  __call__(self, *args)
 |      Call self as a function.
 |  
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  A
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, *args, **kwargs)',)",scipy,1.1.0,scipy.interpolate.rbf.Rbf,interpolate.rbf,Rbf,"Python Library Documentation: class Rbf in module scipy.interpolate.rbf

class Rbf(builtins.object)
 |  Rbf(*args)
 |  
 |  A class for radial basis function approximation/interpolation of
 |  n-dimensional scattered data.
 |  
 |  Parameters
 |  ----------
 |  *args : arrays
 |      x, y, z, ..., d, where x, y, z, ... are the coordinates of the nodes
 |      and d is the array of values at the nodes
 |  function : str or callable, optional
 |      The radial basis function, based on the radius, r, given by the norm
 |      (default is Euclidean distance); the default is 'multiquadric'::
 |  
 |          'multiquadric': sqrt((r/self.epsilon)**2 + 1)
 |          'inverse': 1.0/sqrt((r/self.epsilon)**2 + 1)
 |          'gaussian': exp(-(r/self.epsilon)**2)
 |          'linear': r
 |          'cubic': r**3
 |          'quintic': r**5
 |          'thin_plate': r**2 * log(r)
 |  
 |      If callable, then it must take 2 arguments (self, r).  The epsilon
 |      parameter will be available as self.epsilon.  Other keyword
 |      arguments passed in will be available as well.
 |  
 |  epsilon : float, optional
 |      Adjustable constant for gaussian or multiquadrics functions
 |      - defaults to approximate average distance between nodes (which is
 |      a good start).
 |  smooth : float, optional
 |      Values greater than zero increase the smoothness of the
 |      approximation.  0 is for interpolation (default), the function will
 |      always go through the nodal points in this case.
 |  norm : callable, optional
 |      A function that returns the 'distance' between two points, with
 |      inputs as arrays of positions (x, y, z, ...), and an output as an
 |      array of distance.  E.g, the default::
 |  
 |          def euclidean_norm(x1, x2):
 |              return sqrt( ((x1 - x2)**2).sum(axis=0) )
 |  
 |      which is called with ``x1 = x1[ndims, newaxis, :]`` and
 |      ``x2 = x2[ndims, : ,newaxis]`` such that the result is a matrix of the
 |      distances from each point in ``x1`` to each point in ``x2``.
 |  
 |  Examples
 |  --------
 |  >>> from scipy.interpolate import Rbf
 |  >>> x, y, z, d = np.random.rand(4, 50)
 |  >>> rbfi = Rbf(x, y, z, d)  # radial basis function interpolator instance
 |  >>> xi = yi = zi = np.linspace(0, 1, 20)
 |  >>> di = rbfi(xi, yi, zi)   # interpolated values
 |  >>> di.shape
 |  (20,)
 |  
 |  Methods defined here:
 |  
 |  __call__(self, *args)
 |      Call self as a function.
 |  
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  A
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, *args, **kwargs)',)"
scipy,1.1.0,scipy.interpolate.rbf.callable,interpolate.rbf,callable,"Python Library Documentation: function callable in module scipy._lib.six

callable(obj)
",function,"('(obj)',)",scipy,1.1.0,scipy.interpolate.rbf.callable,interpolate.rbf,callable,"Python Library Documentation: function callable in module scipy._lib.six

callable(obj)
",function,"('obj',)","(nan,)","(nan,)","('arg_info',)","('(obj)',)"
scipy,1.1.0,scipy.io.FortranFile,io,FortranFile,"Python Library Documentation: class FortranFile in module scipy.io._fortran

class FortranFile(builtins.object)
 |  A file object for unformatted sequential files from Fortran code.
 |  
 |  Parameters
 |  ----------
 |  filename : file or str
 |      Open file object or filename.
 |  mode : {'r', 'w'}, optional
 |      Read-write mode, default is 'r'.
 |  header_dtype : dtype, optional
 |      Data type of the header. Size and endiness must match the input/output file.
 |  
 |  Notes
 |  -----
 |  These files are broken up into records of unspecified types. The size of
 |  each record is given at the start (although the size of this header is not
 |  standard) and the data is written onto disk without any formatting. Fortran
 |  compilers supporting the BACKSPACE statement will write a second copy of
 |  the size to facilitate backwards seeking.
 |  
 |  This class only supports files written with both sizes for the record.
 |  It also does not support the subrecords used in Intel and gfortran compilers
 |  for records which are greater than 2GB with a 4-byte header.
 |  
 |  An example of an unformatted sequential file in Fortran would be written as::
 |  
 |      OPEN(1, FILE=myfilename, FORM='unformatted')
 |  
 |      WRITE(1) myvariable
 |  
 |  Since this is a non-standard file format, whose contents depend on the
 |  compiler and the endianness of the machine, caution is advised. Files from
 |  gfortran 4.8.0 and gfortran 4.1.2 on x86_64 are known to work.
 |  
 |  Consider using Fortran direct-access files or files from the newer Stream
 |  I/O, which can be easily read by `numpy.fromfile`.
 |  
 |  Examples
 |  --------
 |  To create an unformatted sequential Fortran file:
 |  
 |  >>> from scipy.io import FortranFile
 |  >>> f = FortranFile('test.unf', 'w')
 |  >>> f.write_record(np.array([1,2,3,4,5], dtype=np.int32))
 |  >>> f.write_record(np.linspace(0,1,20).reshape((5,4)).T)
 |  >>> f.close()
 |  
 |  To read this file:
 |  
 |  >>> f = FortranFile('test.unf', 'r')
 |  >>> print(f.read_ints(np.int32))
 |  [1 2 3 4 5]
 |  >>> print(f.read_reals(float).reshape((5,4), order=""F""))
 |  [[0.         0.05263158 0.10526316 0.15789474]
 |   [0.21052632 0.26315789 0.31578947 0.36842105]
 |   [0.42105263 0.47368421 0.52631579 0.57894737]
 |   [0.63157895 0.68421053 0.73684211 0.78947368]
 |   [0.84210526 0.89473684 0.94736842 1.        ]]
 |  >>> f.close()
 |  
 |  Or, in Fortran::
 |  
 |      integer :: a(5), i
 |      double precision :: b(5,4)
 |      open(1, file='test.unf', form='unformatted')
 |      read(1) a
 |      read(1) b
 |      close(1)
 |      write(*,*) a
 |      do i = 1, 5
 |          write(*,*) b(i,:)
 |      end do
 |  
 |  Methods defined here:
 |  
 |  __enter__(self)
 |  
 |  __exit__(self, type, value, tb)
 |  
 |  __init__(self, filename, mode='r', header_dtype=<class 'numpy.uint32'>)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  close(self)
 |      Closes the file. It is unsupported to call any other methods off this
 |      object after closing it. Note that this class supports the 'with'
 |      statement in modern versions of Python, to call this automatically
 |  
 |  read_ints(self, dtype='i4')
 |      Reads a record of a given type from the file, defaulting to an integer
 |      type (``INTEGER*4`` in Fortran).
 |      
 |      Parameters
 |      ----------
 |      dtype : dtype, optional
 |          Data type specifying the size and endiness of the data.
 |      
 |      Returns
 |      -------
 |      data : ndarray
 |          A one-dimensional array object.
 |      
 |      See Also
 |      --------
 |      read_reals
 |      read_record
 |  
 |  read_reals(self, dtype='f8')
 |      Reads a record of a given type from the file, defaulting to a floating
 |      point number (``real*8`` in Fortran).
 |      
 |      Parameters
 |      ----------
 |      dtype : dtype, optional
 |          Data type specifying the size and endiness of the data.
 |      
 |      Returns
 |      -------
 |      data : ndarray
 |          A one-dimensional array object.
 |      
 |      See Also
 |      --------
 |      read_ints
 |      read_record
 |  
 |  read_record(self, *dtypes, **kwargs)
 |      Reads a record of a given type from the file.
 |      
 |      Parameters
 |      ----------
 |      *dtypes : dtypes, optional
 |          Data type(s) specifying the size and endiness of the data.
 |      
 |      Returns
 |      -------
 |      data : ndarray
 |          A one-dimensional array object.
 |      
 |      Notes
 |      -----
 |      If the record contains a multi-dimensional array, you can specify
 |      the size in the dtype. For example::
 |      
 |          INTEGER var(5,4)
 |      
 |      can be read with::
 |      
 |          read_record('(4,5)i4').T
 |      
 |      Note that this function does **not** assume the file data is in Fortran
 |      column major order, so you need to (i) swap the order of dimensions
 |      when reading and (ii) transpose the resulting array.
 |      
 |      Alternatively, you can read the data as a 1D array and handle the
 |      ordering yourself. For example::
 |      
 |          read_record('i4').reshape(5, 4, order='F')
 |      
 |      For records that contain several variables or mixed types (as opposed
 |      to single scalar or array types), give them as separate arguments::
 |      
 |          double precision :: a
 |          integer :: b
 |          write(1) a, b
 |      
 |          record = f.read_record('<f4', '<i4')
 |          a = record[0]  # first number
 |          b = record[1]  # second number
 |      
 |      and if any of the variables are arrays, the shape can be specified as
 |      the third item in the relevant dtype::
 |      
 |          double precision :: a
 |          integer :: b(3,4)
 |          write(1) a, b
 |      
 |          record = f.read_record('<f4', np.dtype(('<i4', (4, 3))))
 |          a = record[0]
 |          b = record[1].T
 |      
 |      Numpy also supports a short syntax for this kind of type::
 |      
 |          record = f.read_record('<f4', '(3,3)<i4')
 |      
 |      See Also
 |      --------
 |      read_reals
 |      read_ints
 |  
 |  write_record(self, *items)
 |      Write a record (including sizes) to the file.
 |      
 |      Parameters
 |      ----------
 |      *items : array_like
 |          The data arrays to write.
 |      
 |      Notes
 |      -----
 |      Writes data items to a file::
 |      
 |          write_record(a.T, b.T, c.T, ...)
 |      
 |          write(1) a, b, c, ...
 |      
 |      Note that data in multidimensional arrays is written in
 |      row-major order --- to make them read correctly by Fortran
 |      programs, you need to transpose the arrays yourself when
 |      writing them.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"(""(self, filename, mode='r', header_dtype=<class 'numpy.uint32'>)"",)",scipy,1.1.0,scipy.io.FortranFile,io,FortranFile,"Python Library Documentation: class FortranFile in module scipy.io._fortran

class FortranFile(builtins.object)
 |  A file object for unformatted sequential files from Fortran code.
 |  
 |  Parameters
 |  ----------
 |  filename : file or str
 |      Open file object or filename.
 |  mode : {'r', 'w'}, optional
 |      Read-write mode, default is 'r'.
 |  header_dtype : dtype, optional
 |      Data type of the header. Size and endiness must match the input/output file.
 |  
 |  Notes
 |  -----
 |  These files are broken up into records of unspecified types. The size of
 |  each record is given at the start (although the size of this header is not
 |  standard) and the data is written onto disk without any formatting. Fortran
 |  compilers supporting the BACKSPACE statement will write a second copy of
 |  the size to facilitate backwards seeking.
 |  
 |  This class only supports files written with both sizes for the record.
 |  It also does not support the subrecords used in Intel and gfortran compilers
 |  for records which are greater than 2GB with a 4-byte header.
 |  
 |  An example of an unformatted sequential file in Fortran would be written as::
 |  
 |      OPEN(1, FILE=myfilename, FORM='unformatted')
 |  
 |      WRITE(1) myvariable
 |  
 |  Since this is a non-standard file format, whose contents depend on the
 |  compiler and the endianness of the machine, caution is advised. Files from
 |  gfortran 4.8.0 and gfortran 4.1.2 on x86_64 are known to work.
 |  
 |  Consider using Fortran direct-access files or files from the newer Stream
 |  I/O, which can be easily read by `numpy.fromfile`.
 |  
 |  Examples
 |  --------
 |  To create an unformatted sequential Fortran file:
 |  
 |  >>> from scipy.io import FortranFile
 |  >>> f = FortranFile('test.unf', 'w')
 |  >>> f.write_record(np.array([1,2,3,4,5], dtype=np.int32))
 |  >>> f.write_record(np.linspace(0,1,20).reshape((5,4)).T)
 |  >>> f.close()
 |  
 |  To read this file:
 |  
 |  >>> f = FortranFile('test.unf', 'r')
 |  >>> print(f.read_ints(np.int32))
 |  [1 2 3 4 5]
 |  >>> print(f.read_reals(float).reshape((5,4), order=""F""))
 |  [[0.         0.05263158 0.10526316 0.15789474]
 |   [0.21052632 0.26315789 0.31578947 0.36842105]
 |   [0.42105263 0.47368421 0.52631579 0.57894737]
 |   [0.63157895 0.68421053 0.73684211 0.78947368]
 |   [0.84210526 0.89473684 0.94736842 1.        ]]
 |  >>> f.close()
 |  
 |  Or, in Fortran::
 |  
 |      integer :: a(5), i
 |      double precision :: b(5,4)
 |      open(1, file='test.unf', form='unformatted')
 |      read(1) a
 |      read(1) b
 |      close(1)
 |      write(*,*) a
 |      do i = 1, 5
 |          write(*,*) b(i,:)
 |      end do
 |  
 |  Methods defined here:
 |  
 |  __enter__(self)
 |  
 |  __exit__(self, type, value, tb)
 |  
 |  __init__(self, filename, mode='r', header_dtype=<class 'numpy.uint32'>)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  close(self)
 |      Closes the file. It is unsupported to call any other methods off this
 |      object after closing it. Note that this class supports the 'with'
 |      statement in modern versions of Python, to call this automatically
 |  
 |  read_ints(self, dtype='i4')
 |      Reads a record of a given type from the file, defaulting to an integer
 |      type (``INTEGER*4`` in Fortran).
 |      
 |      Parameters
 |      ----------
 |      dtype : dtype, optional
 |          Data type specifying the size and endiness of the data.
 |      
 |      Returns
 |      -------
 |      data : ndarray
 |          A one-dimensional array object.
 |      
 |      See Also
 |      --------
 |      read_reals
 |      read_record
 |  
 |  read_reals(self, dtype='f8')
 |      Reads a record of a given type from the file, defaulting to a floating
 |      point number (``real*8`` in Fortran).
 |      
 |      Parameters
 |      ----------
 |      dtype : dtype, optional
 |          Data type specifying the size and endiness of the data.
 |      
 |      Returns
 |      -------
 |      data : ndarray
 |          A one-dimensional array object.
 |      
 |      See Also
 |      --------
 |      read_ints
 |      read_record
 |  
 |  read_record(self, *dtypes, **kwargs)
 |      Reads a record of a given type from the file.
 |      
 |      Parameters
 |      ----------
 |      *dtypes : dtypes, optional
 |          Data type(s) specifying the size and endiness of the data.
 |      
 |      Returns
 |      -------
 |      data : ndarray
 |          A one-dimensional array object.
 |      
 |      Notes
 |      -----
 |      If the record contains a multi-dimensional array, you can specify
 |      the size in the dtype. For example::
 |      
 |          INTEGER var(5,4)
 |      
 |      can be read with::
 |      
 |          read_record('(4,5)i4').T
 |      
 |      Note that this function does **not** assume the file data is in Fortran
 |      column major order, so you need to (i) swap the order of dimensions
 |      when reading and (ii) transpose the resulting array.
 |      
 |      Alternatively, you can read the data as a 1D array and handle the
 |      ordering yourself. For example::
 |      
 |          read_record('i4').reshape(5, 4, order='F')
 |      
 |      For records that contain several variables or mixed types (as opposed
 |      to single scalar or array types), give them as separate arguments::
 |      
 |          double precision :: a
 |          integer :: b
 |          write(1) a, b
 |      
 |          record = f.read_record('<f4', '<i4')
 |          a = record[0]  # first number
 |          b = record[1]  # second number
 |      
 |      and if any of the variables are arrays, the shape can be specified as
 |      the third item in the relevant dtype::
 |      
 |          double precision :: a
 |          integer :: b(3,4)
 |          write(1) a, b
 |      
 |          record = f.read_record('<f4', np.dtype(('<i4', (4, 3))))
 |          a = record[0]
 |          b = record[1].T
 |      
 |      Numpy also supports a short syntax for this kind of type::
 |      
 |          record = f.read_record('<f4', '(3,3)<i4')
 |      
 |      See Also
 |      --------
 |      read_reals
 |      read_ints
 |  
 |  write_record(self, *items)
 |      Write a record (including sizes) to the file.
 |      
 |      Parameters
 |      ----------
 |      *items : array_like
 |          The data arrays to write.
 |      
 |      Notes
 |      -----
 |      Writes data items to a file::
 |      
 |          write_record(a.T, b.T, c.T, ...)
 |      
 |          write(1) a, b, c, ...
 |      
 |      Note that data in multidimensional arrays is written in
 |      row-major order --- to make them read correctly by Fortran
 |      programs, you need to transpose the arrays yourself when
 |      writing them.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'filename', 'mode', 'header_dtype')","(nan, nan, 'r', <class 'numpy.uint32'>)","(nan, nan, 'str', 'type')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(self, filename, mode='r', header_dtype=<class 'numpy.uint32'>)"",)"
scipy,1.1.0,scipy.io._fortran.FortranFile,io._fortran,FortranFile,"Python Library Documentation: class FortranFile in module scipy.io._fortran

class FortranFile(builtins.object)
 |  A file object for unformatted sequential files from Fortran code.
 |  
 |  Parameters
 |  ----------
 |  filename : file or str
 |      Open file object or filename.
 |  mode : {'r', 'w'}, optional
 |      Read-write mode, default is 'r'.
 |  header_dtype : dtype, optional
 |      Data type of the header. Size and endiness must match the input/output file.
 |  
 |  Notes
 |  -----
 |  These files are broken up into records of unspecified types. The size of
 |  each record is given at the start (although the size of this header is not
 |  standard) and the data is written onto disk without any formatting. Fortran
 |  compilers supporting the BACKSPACE statement will write a second copy of
 |  the size to facilitate backwards seeking.
 |  
 |  This class only supports files written with both sizes for the record.
 |  It also does not support the subrecords used in Intel and gfortran compilers
 |  for records which are greater than 2GB with a 4-byte header.
 |  
 |  An example of an unformatted sequential file in Fortran would be written as::
 |  
 |      OPEN(1, FILE=myfilename, FORM='unformatted')
 |  
 |      WRITE(1) myvariable
 |  
 |  Since this is a non-standard file format, whose contents depend on the
 |  compiler and the endianness of the machine, caution is advised. Files from
 |  gfortran 4.8.0 and gfortran 4.1.2 on x86_64 are known to work.
 |  
 |  Consider using Fortran direct-access files or files from the newer Stream
 |  I/O, which can be easily read by `numpy.fromfile`.
 |  
 |  Examples
 |  --------
 |  To create an unformatted sequential Fortran file:
 |  
 |  >>> from scipy.io import FortranFile
 |  >>> f = FortranFile('test.unf', 'w')
 |  >>> f.write_record(np.array([1,2,3,4,5], dtype=np.int32))
 |  >>> f.write_record(np.linspace(0,1,20).reshape((5,4)).T)
 |  >>> f.close()
 |  
 |  To read this file:
 |  
 |  >>> f = FortranFile('test.unf', 'r')
 |  >>> print(f.read_ints(np.int32))
 |  [1 2 3 4 5]
 |  >>> print(f.read_reals(float).reshape((5,4), order=""F""))
 |  [[0.         0.05263158 0.10526316 0.15789474]
 |   [0.21052632 0.26315789 0.31578947 0.36842105]
 |   [0.42105263 0.47368421 0.52631579 0.57894737]
 |   [0.63157895 0.68421053 0.73684211 0.78947368]
 |   [0.84210526 0.89473684 0.94736842 1.        ]]
 |  >>> f.close()
 |  
 |  Or, in Fortran::
 |  
 |      integer :: a(5), i
 |      double precision :: b(5,4)
 |      open(1, file='test.unf', form='unformatted')
 |      read(1) a
 |      read(1) b
 |      close(1)
 |      write(*,*) a
 |      do i = 1, 5
 |          write(*,*) b(i,:)
 |      end do
 |  
 |  Methods defined here:
 |  
 |  __enter__(self)
 |  
 |  __exit__(self, type, value, tb)
 |  
 |  __init__(self, filename, mode='r', header_dtype=<class 'numpy.uint32'>)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  close(self)
 |      Closes the file. It is unsupported to call any other methods off this
 |      object after closing it. Note that this class supports the 'with'
 |      statement in modern versions of Python, to call this automatically
 |  
 |  read_ints(self, dtype='i4')
 |      Reads a record of a given type from the file, defaulting to an integer
 |      type (``INTEGER*4`` in Fortran).
 |      
 |      Parameters
 |      ----------
 |      dtype : dtype, optional
 |          Data type specifying the size and endiness of the data.
 |      
 |      Returns
 |      -------
 |      data : ndarray
 |          A one-dimensional array object.
 |      
 |      See Also
 |      --------
 |      read_reals
 |      read_record
 |  
 |  read_reals(self, dtype='f8')
 |      Reads a record of a given type from the file, defaulting to a floating
 |      point number (``real*8`` in Fortran).
 |      
 |      Parameters
 |      ----------
 |      dtype : dtype, optional
 |          Data type specifying the size and endiness of the data.
 |      
 |      Returns
 |      -------
 |      data : ndarray
 |          A one-dimensional array object.
 |      
 |      See Also
 |      --------
 |      read_ints
 |      read_record
 |  
 |  read_record(self, *dtypes, **kwargs)
 |      Reads a record of a given type from the file.
 |      
 |      Parameters
 |      ----------
 |      *dtypes : dtypes, optional
 |          Data type(s) specifying the size and endiness of the data.
 |      
 |      Returns
 |      -------
 |      data : ndarray
 |          A one-dimensional array object.
 |      
 |      Notes
 |      -----
 |      If the record contains a multi-dimensional array, you can specify
 |      the size in the dtype. For example::
 |      
 |          INTEGER var(5,4)
 |      
 |      can be read with::
 |      
 |          read_record('(4,5)i4').T
 |      
 |      Note that this function does **not** assume the file data is in Fortran
 |      column major order, so you need to (i) swap the order of dimensions
 |      when reading and (ii) transpose the resulting array.
 |      
 |      Alternatively, you can read the data as a 1D array and handle the
 |      ordering yourself. For example::
 |      
 |          read_record('i4').reshape(5, 4, order='F')
 |      
 |      For records that contain several variables or mixed types (as opposed
 |      to single scalar or array types), give them as separate arguments::
 |      
 |          double precision :: a
 |          integer :: b
 |          write(1) a, b
 |      
 |          record = f.read_record('<f4', '<i4')
 |          a = record[0]  # first number
 |          b = record[1]  # second number
 |      
 |      and if any of the variables are arrays, the shape can be specified as
 |      the third item in the relevant dtype::
 |      
 |          double precision :: a
 |          integer :: b(3,4)
 |          write(1) a, b
 |      
 |          record = f.read_record('<f4', np.dtype(('<i4', (4, 3))))
 |          a = record[0]
 |          b = record[1].T
 |      
 |      Numpy also supports a short syntax for this kind of type::
 |      
 |          record = f.read_record('<f4', '(3,3)<i4')
 |      
 |      See Also
 |      --------
 |      read_reals
 |      read_ints
 |  
 |  write_record(self, *items)
 |      Write a record (including sizes) to the file.
 |      
 |      Parameters
 |      ----------
 |      *items : array_like
 |          The data arrays to write.
 |      
 |      Notes
 |      -----
 |      Writes data items to a file::
 |      
 |          write_record(a.T, b.T, c.T, ...)
 |      
 |          write(1) a, b, c, ...
 |      
 |      Note that data in multidimensional arrays is written in
 |      row-major order --- to make them read correctly by Fortran
 |      programs, you need to transpose the arrays yourself when
 |      writing them.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"(""(self, filename, mode='r', header_dtype=<class 'numpy.uint32'>)"",)",scipy,1.1.0,scipy.io._fortran.FortranFile,io._fortran,FortranFile,"Python Library Documentation: class FortranFile in module scipy.io._fortran

class FortranFile(builtins.object)
 |  A file object for unformatted sequential files from Fortran code.
 |  
 |  Parameters
 |  ----------
 |  filename : file or str
 |      Open file object or filename.
 |  mode : {'r', 'w'}, optional
 |      Read-write mode, default is 'r'.
 |  header_dtype : dtype, optional
 |      Data type of the header. Size and endiness must match the input/output file.
 |  
 |  Notes
 |  -----
 |  These files are broken up into records of unspecified types. The size of
 |  each record is given at the start (although the size of this header is not
 |  standard) and the data is written onto disk without any formatting. Fortran
 |  compilers supporting the BACKSPACE statement will write a second copy of
 |  the size to facilitate backwards seeking.
 |  
 |  This class only supports files written with both sizes for the record.
 |  It also does not support the subrecords used in Intel and gfortran compilers
 |  for records which are greater than 2GB with a 4-byte header.
 |  
 |  An example of an unformatted sequential file in Fortran would be written as::
 |  
 |      OPEN(1, FILE=myfilename, FORM='unformatted')
 |  
 |      WRITE(1) myvariable
 |  
 |  Since this is a non-standard file format, whose contents depend on the
 |  compiler and the endianness of the machine, caution is advised. Files from
 |  gfortran 4.8.0 and gfortran 4.1.2 on x86_64 are known to work.
 |  
 |  Consider using Fortran direct-access files or files from the newer Stream
 |  I/O, which can be easily read by `numpy.fromfile`.
 |  
 |  Examples
 |  --------
 |  To create an unformatted sequential Fortran file:
 |  
 |  >>> from scipy.io import FortranFile
 |  >>> f = FortranFile('test.unf', 'w')
 |  >>> f.write_record(np.array([1,2,3,4,5], dtype=np.int32))
 |  >>> f.write_record(np.linspace(0,1,20).reshape((5,4)).T)
 |  >>> f.close()
 |  
 |  To read this file:
 |  
 |  >>> f = FortranFile('test.unf', 'r')
 |  >>> print(f.read_ints(np.int32))
 |  [1 2 3 4 5]
 |  >>> print(f.read_reals(float).reshape((5,4), order=""F""))
 |  [[0.         0.05263158 0.10526316 0.15789474]
 |   [0.21052632 0.26315789 0.31578947 0.36842105]
 |   [0.42105263 0.47368421 0.52631579 0.57894737]
 |   [0.63157895 0.68421053 0.73684211 0.78947368]
 |   [0.84210526 0.89473684 0.94736842 1.        ]]
 |  >>> f.close()
 |  
 |  Or, in Fortran::
 |  
 |      integer :: a(5), i
 |      double precision :: b(5,4)
 |      open(1, file='test.unf', form='unformatted')
 |      read(1) a
 |      read(1) b
 |      close(1)
 |      write(*,*) a
 |      do i = 1, 5
 |          write(*,*) b(i,:)
 |      end do
 |  
 |  Methods defined here:
 |  
 |  __enter__(self)
 |  
 |  __exit__(self, type, value, tb)
 |  
 |  __init__(self, filename, mode='r', header_dtype=<class 'numpy.uint32'>)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  close(self)
 |      Closes the file. It is unsupported to call any other methods off this
 |      object after closing it. Note that this class supports the 'with'
 |      statement in modern versions of Python, to call this automatically
 |  
 |  read_ints(self, dtype='i4')
 |      Reads a record of a given type from the file, defaulting to an integer
 |      type (``INTEGER*4`` in Fortran).
 |      
 |      Parameters
 |      ----------
 |      dtype : dtype, optional
 |          Data type specifying the size and endiness of the data.
 |      
 |      Returns
 |      -------
 |      data : ndarray
 |          A one-dimensional array object.
 |      
 |      See Also
 |      --------
 |      read_reals
 |      read_record
 |  
 |  read_reals(self, dtype='f8')
 |      Reads a record of a given type from the file, defaulting to a floating
 |      point number (``real*8`` in Fortran).
 |      
 |      Parameters
 |      ----------
 |      dtype : dtype, optional
 |          Data type specifying the size and endiness of the data.
 |      
 |      Returns
 |      -------
 |      data : ndarray
 |          A one-dimensional array object.
 |      
 |      See Also
 |      --------
 |      read_ints
 |      read_record
 |  
 |  read_record(self, *dtypes, **kwargs)
 |      Reads a record of a given type from the file.
 |      
 |      Parameters
 |      ----------
 |      *dtypes : dtypes, optional
 |          Data type(s) specifying the size and endiness of the data.
 |      
 |      Returns
 |      -------
 |      data : ndarray
 |          A one-dimensional array object.
 |      
 |      Notes
 |      -----
 |      If the record contains a multi-dimensional array, you can specify
 |      the size in the dtype. For example::
 |      
 |          INTEGER var(5,4)
 |      
 |      can be read with::
 |      
 |          read_record('(4,5)i4').T
 |      
 |      Note that this function does **not** assume the file data is in Fortran
 |      column major order, so you need to (i) swap the order of dimensions
 |      when reading and (ii) transpose the resulting array.
 |      
 |      Alternatively, you can read the data as a 1D array and handle the
 |      ordering yourself. For example::
 |      
 |          read_record('i4').reshape(5, 4, order='F')
 |      
 |      For records that contain several variables or mixed types (as opposed
 |      to single scalar or array types), give them as separate arguments::
 |      
 |          double precision :: a
 |          integer :: b
 |          write(1) a, b
 |      
 |          record = f.read_record('<f4', '<i4')
 |          a = record[0]  # first number
 |          b = record[1]  # second number
 |      
 |      and if any of the variables are arrays, the shape can be specified as
 |      the third item in the relevant dtype::
 |      
 |          double precision :: a
 |          integer :: b(3,4)
 |          write(1) a, b
 |      
 |          record = f.read_record('<f4', np.dtype(('<i4', (4, 3))))
 |          a = record[0]
 |          b = record[1].T
 |      
 |      Numpy also supports a short syntax for this kind of type::
 |      
 |          record = f.read_record('<f4', '(3,3)<i4')
 |      
 |      See Also
 |      --------
 |      read_reals
 |      read_ints
 |  
 |  write_record(self, *items)
 |      Write a record (including sizes) to the file.
 |      
 |      Parameters
 |      ----------
 |      *items : array_like
 |          The data arrays to write.
 |      
 |      Notes
 |      -----
 |      Writes data items to a file::
 |      
 |          write_record(a.T, b.T, c.T, ...)
 |      
 |          write(1) a, b, c, ...
 |      
 |      Note that data in multidimensional arrays is written in
 |      row-major order --- to make them read correctly by Fortran
 |      programs, you need to transpose the arrays yourself when
 |      writing them.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'filename', 'mode', 'header_dtype')","(nan, nan, 'r', <class 'numpy.uint32'>)","(nan, nan, 'str', 'type')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(self, filename, mode='r', header_dtype=<class 'numpy.uint32'>)"",)"
scipy,1.1.0,scipy.io.arff.arffread.ArffError,io.arff.arffread,ArffError,"Python Library Documentation: class ArffError in module scipy.io.arff.arffread

class ArffError(builtins.OSError)
 |  Base class for I/O related errors.
 |  
 |  Method resolution order:
 |      ArffError
 |      builtins.OSError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.OSError:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.OSError:
 |  
 |  characters_written
 |  
 |  errno
 |      POSIX exception code
 |  
 |  filename
 |      exception filename
 |  
 |  filename2
 |      second exception filename
 |  
 |  strerror
 |      exception strerror
 |  
 |  winerror
 |      Win32 exception code
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.arff.arffread.ArffError,io.arff.arffread,ArffError,"Python Library Documentation: class ArffError in module scipy.io.arff.arffread

class ArffError(builtins.OSError)
 |  Base class for I/O related errors.
 |  
 |  Method resolution order:
 |      ArffError
 |      builtins.OSError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.OSError:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.OSError:
 |  
 |  characters_written
 |  
 |  errno
 |      POSIX exception code
 |  
 |  filename
 |      exception filename
 |  
 |  filename2
 |      second exception filename
 |  
 |  strerror
 |      exception strerror
 |  
 |  winerror
 |      Win32 exception code
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.arff.arffread.MetaData,io.arff.arffread,MetaData,"Python Library Documentation: class MetaData in module scipy.io.arff.arffread

class MetaData(builtins.object)
 |  Small container to keep useful information on a ARFF dataset.
 |  
 |  Knows about attributes names and types.
 |  
 |  Examples
 |  --------
 |  ::
 |  
 |      data, meta = loadarff('iris.arff')
 |      # This will print the attributes names of the iris.arff dataset
 |      for i in meta:
 |          print(i)
 |      # This works too
 |      meta.names()
 |      # Getting attribute type
 |      types = meta.types()
 |  
 |  Notes
 |  -----
 |  Also maintains the list of attributes in order, i.e. doing for i in
 |  meta, where meta is an instance of MetaData, will return the
 |  different attribute names in the order they were defined.
 |  
 |  Methods defined here:
 |  
 |  __getitem__(self, key)
 |  
 |  __init__(self, rel, attr)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self)
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  names(self)
 |      Return the list of attribute names.
 |  
 |  types(self)
 |      Return the list of attribute types.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, rel, attr)',)",scipy,1.1.0,scipy.io.arff.arffread.MetaData,io.arff.arffread,MetaData,"Python Library Documentation: class MetaData in module scipy.io.arff.arffread

class MetaData(builtins.object)
 |  Small container to keep useful information on a ARFF dataset.
 |  
 |  Knows about attributes names and types.
 |  
 |  Examples
 |  --------
 |  ::
 |  
 |      data, meta = loadarff('iris.arff')
 |      # This will print the attributes names of the iris.arff dataset
 |      for i in meta:
 |          print(i)
 |      # This works too
 |      meta.names()
 |      # Getting attribute type
 |      types = meta.types()
 |  
 |  Notes
 |  -----
 |  Also maintains the list of attributes in order, i.e. doing for i in
 |  meta, where meta is an instance of MetaData, will return the
 |  different attribute names in the order they were defined.
 |  
 |  Methods defined here:
 |  
 |  __getitem__(self, key)
 |  
 |  __init__(self, rel, attr)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self)
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  names(self)
 |      Return the list of attribute names.
 |  
 |  types(self)
 |      Return the list of attribute types.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'rel', 'attr')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(self, rel, attr)',)"
scipy,1.1.0,scipy.io.arff.arffread.ParseArffError,io.arff.arffread,ParseArffError,"Python Library Documentation: class ParseArffError in module scipy.io.arff.arffread

class ParseArffError(ArffError)
 |  Base class for I/O related errors.
 |  
 |  Method resolution order:
 |      ParseArffError
 |      ArffError
 |      builtins.OSError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors inherited from ArffError:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.OSError:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.OSError:
 |  
 |  characters_written
 |  
 |  errno
 |      POSIX exception code
 |  
 |  filename
 |      exception filename
 |  
 |  filename2
 |      second exception filename
 |  
 |  strerror
 |      exception strerror
 |  
 |  winerror
 |      Win32 exception code
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.arff.arffread.ParseArffError,io.arff.arffread,ParseArffError,"Python Library Documentation: class ParseArffError in module scipy.io.arff.arffread

class ParseArffError(ArffError)
 |  Base class for I/O related errors.
 |  
 |  Method resolution order:
 |      ParseArffError
 |      ArffError
 |      builtins.OSError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors inherited from ArffError:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.OSError:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.OSError:
 |  
 |  characters_written
 |  
 |  errno
 |      POSIX exception code
 |  
 |  filename
 |      exception filename
 |  
 |  filename2
 |      second exception filename
 |  
 |  strerror
 |      exception strerror
 |  
 |  winerror
 |      Win32 exception code
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.arff.arffread._loadarff,io.arff.arffread,_loadarff,"Python Library Documentation: function _loadarff in module scipy.io.arff.arffread

_loadarff(ofile)
",function,"('(ofile)',)",scipy,1.1.0,scipy.io.arff.arffread._loadarff,io.arff.arffread,_loadarff,"Python Library Documentation: function _loadarff in module scipy.io.arff.arffread

_loadarff(ofile)
",function,"('ofile',)","(nan,)","(nan,)","('arg_info',)","('(ofile)',)"
scipy,1.1.0,scipy.io.arff.arffread.basic_stats,io.arff.arffread,basic_stats,"Python Library Documentation: function basic_stats in module scipy.io.arff.arffread

basic_stats(data)
    #-----
    # Misc
    #-----
",function,"('(data)',)",scipy,1.1.0,scipy.io.arff.arffread.basic_stats,io.arff.arffread,basic_stats,"Python Library Documentation: function basic_stats in module scipy.io.arff.arffread

basic_stats(data)
    #-----
    # Misc
    #-----
",function,"('data',)","(nan,)","(nan,)","('arg_info',)","('(data)',)"
scipy,1.1.0,scipy.io.arff.arffread.get_date_format,io.arff.arffread,get_date_format,"Python Library Documentation: function get_date_format in module scipy.io.arff.arffread

get_date_format(atrv)
",function,"('(atrv)',)",scipy,1.1.0,scipy.io.arff.arffread.get_date_format,io.arff.arffread,get_date_format,"Python Library Documentation: function get_date_format in module scipy.io.arff.arffread

get_date_format(atrv)
",function,"('atrv',)","(nan,)","(nan,)","('arg_info',)","('(atrv)',)"
scipy,1.1.0,scipy.io.arff.arffread.get_ndata,io.arff.arffread,get_ndata,"Python Library Documentation: function get_ndata in module scipy.io.arff.arffread

get_ndata(ofile)
    Read the whole file to get number of data attributes.
",function,"('(ofile)',)",scipy,1.1.0,scipy.io.arff.arffread.get_ndata,io.arff.arffread,get_ndata,"Python Library Documentation: function get_ndata in module scipy.io.arff.arffread

get_ndata(ofile)
    Read the whole file to get number of data attributes.
",function,"('ofile',)","(nan,)","(nan,)","('arg_info',)","('(ofile)',)"
scipy,1.1.0,scipy.io.arff.arffread.get_nom_val,io.arff.arffread,get_nom_val,"Python Library Documentation: function get_nom_val in module scipy.io.arff.arffread

get_nom_val(atrv)
    Given a string containing a nominal type, returns a tuple of the
    possible values.
    
    A nominal type is defined as something framed between braces ({}).
    
    Parameters
    ----------
    atrv : str
       Nominal type definition
    
    Returns
    -------
    poss_vals : tuple
       possible values
    
    Examples
    --------
    >>> get_nom_val(""{floup, bouga, fl, ratata}"")
    ('floup', 'bouga', 'fl', 'ratata')
",function,"('(atrv)',)",scipy,1.1.0,scipy.io.arff.arffread.get_nom_val,io.arff.arffread,get_nom_val,"Python Library Documentation: function get_nom_val in module scipy.io.arff.arffread

get_nom_val(atrv)
    Given a string containing a nominal type, returns a tuple of the
    possible values.
    
    A nominal type is defined as something framed between braces ({}).
    
    Parameters
    ----------
    atrv : str
       Nominal type definition
    
    Returns
    -------
    poss_vals : tuple
       possible values
    
    Examples
    --------
    >>> get_nom_val(""{floup, bouga, fl, ratata}"")
    ('floup', 'bouga', 'fl', 'ratata')
",function,"('atrv',)","(nan,)","(nan,)","('arg_info',)","('(atrv)',)"
scipy,1.1.0,scipy.io.arff.arffread.get_nominal,io.arff.arffread,get_nominal,"Python Library Documentation: function get_nominal in module scipy.io.arff.arffread

get_nominal(attribute)
    If attribute is nominal, returns a list of the values
",function,"('(attribute)',)",scipy,1.1.0,scipy.io.arff.arffread.get_nominal,io.arff.arffread,get_nominal,"Python Library Documentation: function get_nominal in module scipy.io.arff.arffread

get_nominal(attribute)
    If attribute is nominal, returns a list of the values
",function,"('attribute',)","(nan,)","(nan,)","('arg_info',)","('(attribute)',)"
scipy,1.1.0,scipy.io.arff.arffread.go_data,io.arff.arffread,go_data,"Python Library Documentation: function go_data in module scipy.io.arff.arffread

go_data(ofile)
    Skip header.
    
    the first next() call of the returned iterator will be the @data line
",function,"('(ofile)',)",scipy,1.1.0,scipy.io.arff.arffread.go_data,io.arff.arffread,go_data,"Python Library Documentation: function go_data in module scipy.io.arff.arffread

go_data(ofile)
    Skip header.
    
    the first next() call of the returned iterator will be the @data line
",function,"('ofile',)","(nan,)","(nan,)","('arg_info',)","('(ofile)',)"
scipy,1.1.0,scipy.io.arff.arffread.loadarff,io.arff.arffread,loadarff,"Python Library Documentation: function loadarff in module scipy.io.arff.arffread

loadarff(f)
    Read an arff file.
    
    The data is returned as a record array, which can be accessed much like
    a dictionary of numpy arrays.  For example, if one of the attributes is
    called 'pressure', then its first 10 data points can be accessed from the
    ``data`` record array like so: ``data['pressure'][0:10]``
    
    
    Parameters
    ----------
    f : file-like or str
       File-like object to read from, or filename to open.
    
    Returns
    -------
    data : record array
       The data of the arff file, accessible by attribute names.
    meta : `MetaData`
       Contains information about the arff file such as name and
       type of attributes, the relation (name of the dataset), etc...
    
    Raises
    ------
    ParseArffError
        This is raised if the given file is not ARFF-formatted.
    NotImplementedError
        The ARFF file has an attribute which is not supported yet.
    
    Notes
    -----
    
    This function should be able to read most arff files. Not
    implemented functionality include:
    
    * date type attributes
    * string type attributes
    
    It can read files with numeric and nominal attributes.  It cannot read
    files with sparse data ({} in the file).  However, this function can
    read files with missing data (? in the file), representing the data
    points as NaNs.
    
    Examples
    --------
    >>> from scipy.io import arff
    >>> from io import StringIO
    >>> content = """"""
    ... @relation foo
    ... @attribute width  numeric
    ... @attribute height numeric
    ... @attribute color  {red,green,blue,yellow,black}
    ... @data
    ... 5.0,3.25,blue
    ... 4.5,3.75,green
    ... 3.0,4.00,red
    ... """"""
    >>> f = StringIO(content)
    >>> data, meta = arff.loadarff(f)
    >>> data
    array([(5.0, 3.25, 'blue'), (4.5, 3.75, 'green'), (3.0, 4.0, 'red')],
          dtype=[('width', '<f8'), ('height', '<f8'), ('color', '|S6')])
    >>> meta
    Dataset: foo
        width's type is numeric
        height's type is numeric
        color's type is nominal, range is ('red', 'green', 'blue', 'yellow', 'black')
",function,"('(f)',)",scipy,1.1.0,scipy.io.arff.arffread.loadarff,io.arff.arffread,loadarff,"Python Library Documentation: function loadarff in module scipy.io.arff.arffread

loadarff(f)
    Read an arff file.
    
    The data is returned as a record array, which can be accessed much like
    a dictionary of numpy arrays.  For example, if one of the attributes is
    called 'pressure', then its first 10 data points can be accessed from the
    ``data`` record array like so: ``data['pressure'][0:10]``
    
    
    Parameters
    ----------
    f : file-like or str
       File-like object to read from, or filename to open.
    
    Returns
    -------
    data : record array
       The data of the arff file, accessible by attribute names.
    meta : `MetaData`
       Contains information about the arff file such as name and
       type of attributes, the relation (name of the dataset), etc...
    
    Raises
    ------
    ParseArffError
        This is raised if the given file is not ARFF-formatted.
    NotImplementedError
        The ARFF file has an attribute which is not supported yet.
    
    Notes
    -----
    
    This function should be able to read most arff files. Not
    implemented functionality include:
    
    * date type attributes
    * string type attributes
    
    It can read files with numeric and nominal attributes.  It cannot read
    files with sparse data ({} in the file).  However, this function can
    read files with missing data (? in the file), representing the data
    points as NaNs.
    
    Examples
    --------
    >>> from scipy.io import arff
    >>> from io import StringIO
    >>> content = """"""
    ... @relation foo
    ... @attribute width  numeric
    ... @attribute height numeric
    ... @attribute color  {red,green,blue,yellow,black}
    ... @data
    ... 5.0,3.25,blue
    ... 4.5,3.75,green
    ... 3.0,4.00,red
    ... """"""
    >>> f = StringIO(content)
    >>> data, meta = arff.loadarff(f)
    >>> data
    array([(5.0, 3.25, 'blue'), (4.5, 3.75, 'green'), (3.0, 4.0, 'red')],
          dtype=[('width', '<f8'), ('height', '<f8'), ('color', '|S6')])
    >>> meta
    Dataset: foo
        width's type is numeric
        height's type is numeric
        color's type is nominal, range is ('red', 'green', 'blue', 'yellow', 'black')
",function,"('f',)","(nan,)","(nan,)","('arg_info',)","('(f)',)"
scipy,1.1.0,scipy.io.arff.arffread.maxnomlen,io.arff.arffread,maxnomlen,"Python Library Documentation: function maxnomlen in module scipy.io.arff.arffread

maxnomlen(atrv)
    Given a string containing a nominal type definition, returns the
    string len of the biggest component.
    
    A nominal type is defined as seomthing framed between brace ({}).
    
    Parameters
    ----------
    atrv : str
       Nominal type definition
    
    Returns
    -------
    slen : int
       length of longest component
    
    Examples
    --------
    maxnomlen(""{floup, bouga, fl, ratata}"") returns 6 (the size of
    ratata, the longest nominal value).
    
    >>> maxnomlen(""{floup, bouga, fl, ratata}"")
    6
",function,"('(atrv)',)",scipy,1.1.0,scipy.io.arff.arffread.maxnomlen,io.arff.arffread,maxnomlen,"Python Library Documentation: function maxnomlen in module scipy.io.arff.arffread

maxnomlen(atrv)
    Given a string containing a nominal type definition, returns the
    string len of the biggest component.
    
    A nominal type is defined as seomthing framed between brace ({}).
    
    Parameters
    ----------
    atrv : str
       Nominal type definition
    
    Returns
    -------
    slen : int
       length of longest component
    
    Examples
    --------
    maxnomlen(""{floup, bouga, fl, ratata}"") returns 6 (the size of
    ratata, the longest nominal value).
    
    >>> maxnomlen(""{floup, bouga, fl, ratata}"")
    6
",function,"('atrv',)","(nan,)","(nan,)","('arg_info',)","('(atrv)',)"
scipy,1.1.0,scipy.io.arff.arffread.parse_type,io.arff.arffread,parse_type,"Python Library Documentation: function parse_type in module scipy.io.arff.arffread

parse_type(attrtype)
    Given an arff attribute value (meta data), returns its type.
    
    Expect the value to be a name.
",function,"('(attrtype)',)",scipy,1.1.0,scipy.io.arff.arffread.parse_type,io.arff.arffread,parse_type,"Python Library Documentation: function parse_type in module scipy.io.arff.arffread

parse_type(attrtype)
    Given an arff attribute value (meta data), returns its type.
    
    Expect the value to be a name.
",function,"('attrtype',)","(nan,)","(nan,)","('arg_info',)","('(attrtype)',)"
scipy,1.1.0,scipy.io.arff.arffread.partial,io.arff.arffread,partial,"Python Library Documentation: class partial in module functools

class partial(builtins.object)
 |  partial(func, *args, **keywords) - new function with partial application
 |  of the given arguments and keywords.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, /, *args, **kwargs)
 |      Call self as a function.
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |  
 |  args
 |      tuple of arguments to future partial calls
 |  
 |  func
 |      function object to use in future partial calls
 |  
 |  keywords
 |      dictionary of keyword arguments to future partial calls
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.arff.arffread.partial,io.arff.arffread,partial,"Python Library Documentation: class partial in module functools

class partial(builtins.object)
 |  partial(func, *args, **keywords) - new function with partial application
 |  of the given arguments and keywords.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, /, *args, **kwargs)
 |      Call self as a function.
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |  
 |  args
 |      tuple of arguments to future partial calls
 |  
 |  func
 |      function object to use in future partial calls
 |  
 |  keywords
 |      dictionary of keyword arguments to future partial calls
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.arff.arffread.print_attribute,io.arff.arffread,print_attribute,"Python Library Documentation: function print_attribute in module scipy.io.arff.arffread

print_attribute(name, tp, data)
",function,"('(name, tp, data)',)",scipy,1.1.0,scipy.io.arff.arffread.print_attribute,io.arff.arffread,print_attribute,"Python Library Documentation: function print_attribute in module scipy.io.arff.arffread

print_attribute(name, tp, data)
",function,"('name', 'tp', 'data')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(name, tp, data)',)"
scipy,1.1.0,scipy.io.arff.arffread.read_data_list,io.arff.arffread,read_data_list,"Python Library Documentation: function read_data_list in module scipy.io.arff.arffread

read_data_list(ofile)
    Read each line of the iterable and put it in a list.
",function,"('(ofile)',)",scipy,1.1.0,scipy.io.arff.arffread.read_data_list,io.arff.arffread,read_data_list,"Python Library Documentation: function read_data_list in module scipy.io.arff.arffread

read_data_list(ofile)
    Read each line of the iterable and put it in a list.
",function,"('ofile',)","(nan,)","(nan,)","('arg_info',)","('(ofile)',)"
scipy,1.1.0,scipy.io.arff.arffread.read_header,io.arff.arffread,read_header,"Python Library Documentation: function read_header in module scipy.io.arff.arffread

read_header(ofile)
    Read the header of the iterable ofile.
",function,"('(ofile)',)",scipy,1.1.0,scipy.io.arff.arffread.read_header,io.arff.arffread,read_header,"Python Library Documentation: function read_header in module scipy.io.arff.arffread

read_header(ofile)
    Read the header of the iterable ofile.
",function,"('ofile',)","(nan,)","(nan,)","('arg_info',)","('(ofile)',)"
scipy,1.1.0,scipy.io.arff.arffread.safe_date,io.arff.arffread,safe_date,"Python Library Documentation: function safe_date in module scipy.io.arff.arffread

safe_date(value, date_format, datetime_unit)
",function,"('(value, date_format, datetime_unit)',)",scipy,1.1.0,scipy.io.arff.arffread.safe_date,io.arff.arffread,safe_date,"Python Library Documentation: function safe_date in module scipy.io.arff.arffread

safe_date(value, date_format, datetime_unit)
",function,"('value', 'date_format', 'datetime_unit')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(value, date_format, datetime_unit)',)"
scipy,1.1.0,scipy.io.arff.arffread.safe_float,io.arff.arffread,safe_float,"Python Library Documentation: function safe_float in module scipy.io.arff.arffread

safe_float(x)
    given a string x, convert it to a float. If the stripped string is a ?,
    return a Nan (missing value).
    
    Parameters
    ----------
    x : str
       string to convert
    
    Returns
    -------
    f : float
       where float can be nan
    
    Examples
    --------
    >>> safe_float('1')
    1.0
    >>> safe_float('1\n')
    1.0
    >>> safe_float('?\n')
    nan
",function,"('(x)',)",scipy,1.1.0,scipy.io.arff.arffread.safe_float,io.arff.arffread,safe_float,"Python Library Documentation: function safe_float in module scipy.io.arff.arffread

safe_float(x)
    given a string x, convert it to a float. If the stripped string is a ?,
    return a Nan (missing value).
    
    Parameters
    ----------
    x : str
       string to convert
    
    Returns
    -------
    f : float
       where float can be nan
    
    Examples
    --------
    >>> safe_float('1')
    1.0
    >>> safe_float('1\n')
    1.0
    >>> safe_float('?\n')
    nan
",function,"('x',)","(nan,)","(nan,)","('arg_info',)","('(x)',)"
scipy,1.1.0,scipy.io.arff.arffread.safe_nominal,io.arff.arffread,safe_nominal,"Python Library Documentation: function safe_nominal in module scipy.io.arff.arffread

safe_nominal(value, pvalue)
",function,"('(value, pvalue)',)",scipy,1.1.0,scipy.io.arff.arffread.safe_nominal,io.arff.arffread,safe_nominal,"Python Library Documentation: function safe_nominal in module scipy.io.arff.arffread

safe_nominal(value, pvalue)
",function,"('value', 'pvalue')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(value, pvalue)',)"
scipy,1.1.0,scipy.io.arff.arffread.test_weka,io.arff.arffread,test_weka,"Python Library Documentation: function test_weka in module scipy.io.arff.arffread

test_weka(filename)
",function,"('(filename)',)",scipy,1.1.0,scipy.io.arff.arffread.test_weka,io.arff.arffread,test_weka,"Python Library Documentation: function test_weka in module scipy.io.arff.arffread

test_weka(filename)
",function,"('filename',)","(nan,)","(nan,)","('arg_info',)","('(filename)',)"
scipy,1.1.0,scipy.io.arff.arffread.tokenize_attribute,io.arff.arffread,tokenize_attribute,"Python Library Documentation: function tokenize_attribute in module scipy.io.arff.arffread

tokenize_attribute(iterable, attribute)
    Parse a raw string in header (eg starts by @attribute).
    
    Given a raw string attribute, try to get the name and type of the
    attribute. Constraints:
    
    * The first line must start with @attribute (case insensitive, and
      space like characters before @attribute are allowed)
    * Works also if the attribute is spread on multilines.
    * Works if empty lines or comments are in between
    
    Parameters
    ----------
    attribute : str
       the attribute string.
    
    Returns
    -------
    name : str
       name of the attribute
    value : str
       value of the attribute
    next : str
       next line to be parsed
    
    Examples
    --------
    If attribute is a string defined in python as r""floupi real"", will
    return floupi as name, and real as value.
    
    >>> iterable = iter([0] * 10) # dummy iterator
    >>> tokenize_attribute(iterable, r""@attribute floupi real"")
    ('floupi', 'real', 0)
    
    If attribute is r""'floupi 2' real"", will return 'floupi 2' as name,
    and real as value.
    
    >>> tokenize_attribute(iterable, r""  @attribute 'floupi 2' real   "")
    ('floupi 2', 'real', 0)
",function,"('(iterable, attribute)',)",scipy,1.1.0,scipy.io.arff.arffread.tokenize_attribute,io.arff.arffread,tokenize_attribute,"Python Library Documentation: function tokenize_attribute in module scipy.io.arff.arffread

tokenize_attribute(iterable, attribute)
    Parse a raw string in header (eg starts by @attribute).
    
    Given a raw string attribute, try to get the name and type of the
    attribute. Constraints:
    
    * The first line must start with @attribute (case insensitive, and
      space like characters before @attribute are allowed)
    * Works also if the attribute is spread on multilines.
    * Works if empty lines or comments are in between
    
    Parameters
    ----------
    attribute : str
       the attribute string.
    
    Returns
    -------
    name : str
       name of the attribute
    value : str
       value of the attribute
    next : str
       next line to be parsed
    
    Examples
    --------
    If attribute is a string defined in python as r""floupi real"", will
    return floupi as name, and real as value.
    
    >>> iterable = iter([0] * 10) # dummy iterator
    >>> tokenize_attribute(iterable, r""@attribute floupi real"")
    ('floupi', 'real', 0)
    
    If attribute is r""'floupi 2' real"", will return 'floupi 2' as name,
    and real as value.
    
    >>> tokenize_attribute(iterable, r""  @attribute 'floupi 2' real   "")
    ('floupi 2', 'real', 0)
",function,"('iterable', 'attribute')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(iterable, attribute)',)"
scipy,1.1.0,scipy.io.arff.arffread.tokenize_single_comma,io.arff.arffread,tokenize_single_comma,"Python Library Documentation: function tokenize_single_comma in module scipy.io.arff.arffread

tokenize_single_comma(val)
",function,"('(val)',)",scipy,1.1.0,scipy.io.arff.arffread.tokenize_single_comma,io.arff.arffread,tokenize_single_comma,"Python Library Documentation: function tokenize_single_comma in module scipy.io.arff.arffread

tokenize_single_comma(val)
",function,"('val',)","(nan,)","(nan,)","('arg_info',)","('(val)',)"
scipy,1.1.0,scipy.io.arff.arffread.tokenize_single_wcomma,io.arff.arffread,tokenize_single_wcomma,"Python Library Documentation: function tokenize_single_wcomma in module scipy.io.arff.arffread

tokenize_single_wcomma(val)
",function,"('(val)',)",scipy,1.1.0,scipy.io.arff.arffread.tokenize_single_wcomma,io.arff.arffread,tokenize_single_wcomma,"Python Library Documentation: function tokenize_single_wcomma in module scipy.io.arff.arffread

tokenize_single_wcomma(val)
",function,"('val',)","(nan,)","(nan,)","('arg_info',)","('(val)',)"
scipy,1.1.0,scipy.io.harwell_boeing.HBFile,io.harwell_boeing,HBFile,"Python Library Documentation: class HBFile in module scipy.io.harwell_boeing.hb

class HBFile(builtins.object)
 |  Methods defined here:
 |  
 |  __init__(self, file, hb_info=None)
 |      Create a HBFile instance.
 |      
 |      Parameters
 |      ----------
 |      file : file-object
 |          StringIO work as well
 |      hb_info : HBInfo, optional
 |          Should be given as an argument for writing, in which case the file
 |          should be writable.
 |  
 |  read_matrix(self)
 |  
 |  write_matrix(self, m)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  key
 |  
 |  storage
 |  
 |  structure
 |  
 |  title
 |  
 |  type
",class,"('(self, file, hb_info=None)',)",scipy,1.1.0,scipy.io.harwell_boeing.HBFile,io.harwell_boeing,HBFile,"Python Library Documentation: class HBFile in module scipy.io.harwell_boeing.hb

class HBFile(builtins.object)
 |  Methods defined here:
 |  
 |  __init__(self, file, hb_info=None)
 |      Create a HBFile instance.
 |      
 |      Parameters
 |      ----------
 |      file : file-object
 |          StringIO work as well
 |      hb_info : HBInfo, optional
 |          Should be given as an argument for writing, in which case the file
 |          should be writable.
 |  
 |  read_matrix(self)
 |  
 |  write_matrix(self, m)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  key
 |  
 |  storage
 |  
 |  structure
 |  
 |  title
 |  
 |  type
",class,"('self', 'file', 'hb_info')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(self, file, hb_info=None)',)"
scipy,1.1.0,scipy.io.harwell_boeing.HBInfo,io.harwell_boeing,HBInfo,"Python Library Documentation: class HBInfo in module scipy.io.harwell_boeing.hb

class HBInfo(builtins.object)
 |  Methods defined here:
 |  
 |  __init__(self, title, key, total_nlines, pointer_nlines, indices_nlines, values_nlines, mxtype, nrows, ncols, nnon_zeros, pointer_format_str, indices_format_str, values_format_str, right_hand_sides_nlines=0, nelementals=0)
 |      Do not use this directly, but the class ctrs (from_* functions).
 |  
 |  dump(self)
 |      Gives the header corresponding to this instance as a string.
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_data(m, title='Default title', key='0', mxtype=None, fmt=None) from builtins.type
 |      Create a HBInfo instance from an existing sparse matrix.
 |      
 |      Parameters
 |      ----------
 |      m : sparse matrix
 |          the HBInfo instance will derive its parameters from m
 |      title : str
 |          Title to put in the HB header
 |      key : str
 |          Key
 |      mxtype : HBMatrixType
 |          type of the input matrix
 |      fmt : dict
 |          not implemented
 |      
 |      Returns
 |      -------
 |      hb_info : HBInfo instance
 |  
 |  from_file(fid) from builtins.type
 |      Create a HBInfo instance from a file object containing a matrix in the
 |      HB format.
 |      
 |      Parameters
 |      ----------
 |      fid : file-like matrix
 |          File or file-like object containing a matrix in the HB format.
 |      
 |      Returns
 |      -------
 |      hb_info : HBInfo instance
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, title, key, total_nlines, pointer_nlines, indices_nlines, values_nlines, mxtype, nrows, ncols, nnon_zeros, pointer_format_str, indices_format_str, values_format_str, right_hand_sides_nlines=0, nelementals=0)',)",scipy,1.1.0,scipy.io.harwell_boeing.HBInfo,io.harwell_boeing,HBInfo,"Python Library Documentation: class HBInfo in module scipy.io.harwell_boeing.hb

class HBInfo(builtins.object)
 |  Methods defined here:
 |  
 |  __init__(self, title, key, total_nlines, pointer_nlines, indices_nlines, values_nlines, mxtype, nrows, ncols, nnon_zeros, pointer_format_str, indices_format_str, values_format_str, right_hand_sides_nlines=0, nelementals=0)
 |      Do not use this directly, but the class ctrs (from_* functions).
 |  
 |  dump(self)
 |      Gives the header corresponding to this instance as a string.
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_data(m, title='Default title', key='0', mxtype=None, fmt=None) from builtins.type
 |      Create a HBInfo instance from an existing sparse matrix.
 |      
 |      Parameters
 |      ----------
 |      m : sparse matrix
 |          the HBInfo instance will derive its parameters from m
 |      title : str
 |          Title to put in the HB header
 |      key : str
 |          Key
 |      mxtype : HBMatrixType
 |          type of the input matrix
 |      fmt : dict
 |          not implemented
 |      
 |      Returns
 |      -------
 |      hb_info : HBInfo instance
 |  
 |  from_file(fid) from builtins.type
 |      Create a HBInfo instance from a file object containing a matrix in the
 |      HB format.
 |      
 |      Parameters
 |      ----------
 |      fid : file-like matrix
 |          File or file-like object containing a matrix in the HB format.
 |      
 |      Returns
 |      -------
 |      hb_info : HBInfo instance
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'title', 'key', 'total_nlines', 'pointer_nlines', 'indices_nlines', 'values_nlines', 'mxtype', 'nrows', 'ncols', 'nnon_zeros', 'pointer_format_str', 'indices_format_str', 'values_format_str', 'right_hand_sides_nlines', 'nelementals')","(nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, 0, 0)","(nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, 'int', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, title, key, total_nlines, pointer_nlines, indices_nlines, values_nlines, mxtype, nrows, ncols, nnon_zeros, pointer_format_str, indices_format_str, values_format_str, right_hand_sides_nlines=0, nelementals=0)',)"
scipy,1.1.0,scipy.io.harwell_boeing.HBInfo.from_data,io.harwell_boeing.HBInfo,from_data,"Python Library Documentation: method from_data in module scipy.io.harwell_boeing.hb

from_data(m, title='Default title', key='0', mxtype=None, fmt=None) method of builtins.type instance
    Create a HBInfo instance from an existing sparse matrix.
    
    Parameters
    ----------
    m : sparse matrix
        the HBInfo instance will derive its parameters from m
    title : str
        Title to put in the HB header
    key : str
        Key
    mxtype : HBMatrixType
        type of the input matrix
    fmt : dict
        not implemented
    
    Returns
    -------
    hb_info : HBInfo instance
",method,"(""(m, title='Default title', key='0', mxtype=None, fmt=None)"",)",scipy,1.1.0,scipy.io.harwell_boeing.HBInfo.from_data,io.harwell_boeing.HBInfo,from_data,"Python Library Documentation: method from_data in module scipy.io.harwell_boeing.hb

from_data(m, title='Default title', key='0', mxtype=None, fmt=None) method of builtins.type instance
    Create a HBInfo instance from an existing sparse matrix.
    
    Parameters
    ----------
    m : sparse matrix
        the HBInfo instance will derive its parameters from m
    title : str
        Title to put in the HB header
    key : str
        Key
    mxtype : HBMatrixType
        type of the input matrix
    fmt : dict
        not implemented
    
    Returns
    -------
    hb_info : HBInfo instance
",method,"('cls', 'm', 'title', 'key', 'mxtype', 'fmt')","(nan, nan, 'Default title', '0', None, None)","(nan, nan, nan, 'int', 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(m, title='Default title', key='0', mxtype=None, fmt=None)"",)"
scipy,1.1.0,scipy.io.harwell_boeing.HBInfo.from_file,io.harwell_boeing.HBInfo,from_file,"Python Library Documentation: method from_file in module scipy.io.harwell_boeing.hb

from_file(fid) method of builtins.type instance
    Create a HBInfo instance from a file object containing a matrix in the
    HB format.
    
    Parameters
    ----------
    fid : file-like matrix
        File or file-like object containing a matrix in the HB format.
    
    Returns
    -------
    hb_info : HBInfo instance
",method,"('(fid)',)",scipy,1.1.0,scipy.io.harwell_boeing.HBInfo.from_file,io.harwell_boeing.HBInfo,from_file,"Python Library Documentation: method from_file in module scipy.io.harwell_boeing.hb

from_file(fid) method of builtins.type instance
    Create a HBInfo instance from a file object containing a matrix in the
    HB format.
    
    Parameters
    ----------
    fid : file-like matrix
        File or file-like object containing a matrix in the HB format.
    
    Returns
    -------
    hb_info : HBInfo instance
",method,"('cls', 'fid')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(fid)',)"
scipy,1.1.0,scipy.io.harwell_boeing.HBMatrixType,io.harwell_boeing,HBMatrixType,"Python Library Documentation: class HBMatrixType in module scipy.io.harwell_boeing.hb

class HBMatrixType(builtins.object)
 |  Class to hold the matrix type.
 |  
 |  Methods defined here:
 |  
 |  __init__(self, value_type, structure, storage='assembled')
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_fortran(fmt) from builtins.type
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  fortran_format
",class,"(""(self, value_type, structure, storage='assembled')"",)",scipy,1.1.0,scipy.io.harwell_boeing.HBMatrixType,io.harwell_boeing,HBMatrixType,"Python Library Documentation: class HBMatrixType in module scipy.io.harwell_boeing.hb

class HBMatrixType(builtins.object)
 |  Class to hold the matrix type.
 |  
 |  Methods defined here:
 |  
 |  __init__(self, value_type, structure, storage='assembled')
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_fortran(fmt) from builtins.type
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  fortran_format
",class,"('self', 'value_type', 'structure', 'storage')","(nan, nan, nan, 'assembled')","(nan, nan, nan, 'str')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(self, value_type, structure, storage='assembled')"",)"
scipy,1.1.0,scipy.io.harwell_boeing.HBMatrixType.from_fortran,io.harwell_boeing.HBMatrixType,from_fortran,"Python Library Documentation: method from_fortran in module scipy.io.harwell_boeing.hb

from_fortran(fmt) method of builtins.type instance
",method,"('(fmt)',)",scipy,1.1.0,scipy.io.harwell_boeing.HBMatrixType.from_fortran,io.harwell_boeing.HBMatrixType,from_fortran,"Python Library Documentation: method from_fortran in module scipy.io.harwell_boeing.hb

from_fortran(fmt) method of builtins.type instance
",method,"('cls', 'fmt')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(fmt)',)"
scipy,1.1.0,scipy.io.harwell_boeing.MalformedHeader,io.harwell_boeing,MalformedHeader,"Python Library Documentation: class MalformedHeader in module scipy.io.harwell_boeing.hb

class MalformedHeader(builtins.Exception)
 |  Common base class for all non-exit exceptions.
 |  
 |  Method resolution order:
 |      MalformedHeader
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.harwell_boeing.MalformedHeader,io.harwell_boeing,MalformedHeader,"Python Library Documentation: class MalformedHeader in module scipy.io.harwell_boeing.hb

class MalformedHeader(builtins.Exception)
 |  Common base class for all non-exit exceptions.
 |  
 |  Method resolution order:
 |      MalformedHeader
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.harwell_boeing._fortran_format_parser.BadFortranFormat,io.harwell_boeing._fortran_format_parser,BadFortranFormat,"Python Library Documentation: class BadFortranFormat in module scipy.io.harwell_boeing._fortran_format_parser

class BadFortranFormat(builtins.SyntaxError)
 |  Invalid syntax.
 |  
 |  Method resolution order:
 |      BadFortranFormat
 |      builtins.SyntaxError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.SyntaxError:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.SyntaxError:
 |  
 |  filename
 |      exception filename
 |  
 |  lineno
 |      exception lineno
 |  
 |  msg
 |      exception msg
 |  
 |  offset
 |      exception offset
 |  
 |  print_file_and_line
 |      exception print_file_and_line
 |  
 |  text
 |      exception text
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.harwell_boeing._fortran_format_parser.BadFortranFormat,io.harwell_boeing._fortran_format_parser,BadFortranFormat,"Python Library Documentation: class BadFortranFormat in module scipy.io.harwell_boeing._fortran_format_parser

class BadFortranFormat(builtins.SyntaxError)
 |  Invalid syntax.
 |  
 |  Method resolution order:
 |      BadFortranFormat
 |      builtins.SyntaxError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.SyntaxError:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.SyntaxError:
 |  
 |  filename
 |      exception filename
 |  
 |  lineno
 |      exception lineno
 |  
 |  msg
 |      exception msg
 |  
 |  offset
 |      exception offset
 |  
 |  print_file_and_line
 |      exception print_file_and_line
 |  
 |  text
 |      exception text
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.harwell_boeing._fortran_format_parser.ExpFormat,io.harwell_boeing._fortran_format_parser,ExpFormat,"Python Library Documentation: class ExpFormat in module scipy.io.harwell_boeing._fortran_format_parser

class ExpFormat(builtins.object)
 |  Methods defined here:
 |  
 |  __init__(self, width, significand, min=None, repeat=None)
 |      Parameters
 |      ----------
 |      width : int
 |          number of characters taken by the string (includes space).
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_number(n, min=None) from builtins.type
 |      Given a float number, returns a ""reasonable"" ExpFormat instance to
 |      represent any number between -n and n.
 |      
 |      Parameters
 |      ----------
 |      n : float
 |          max number one wants to be able to represent
 |      min : int
 |          minimum number of characters to use for the format
 |      
 |      Returns
 |      -------
 |      res : ExpFormat
 |          ExpFormat instance with reasonable (see Notes) computed width
 |      
 |      Notes
 |      -----
 |      Reasonable should be understood as the minimal string length necessary
 |      to avoid losing precision.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  fortran_format
 |  
 |  python_format
",class,"('(self, width, significand, min=None, repeat=None)',)",scipy,1.1.0,scipy.io.harwell_boeing._fortran_format_parser.ExpFormat,io.harwell_boeing._fortran_format_parser,ExpFormat,"Python Library Documentation: class ExpFormat in module scipy.io.harwell_boeing._fortran_format_parser

class ExpFormat(builtins.object)
 |  Methods defined here:
 |  
 |  __init__(self, width, significand, min=None, repeat=None)
 |      Parameters
 |      ----------
 |      width : int
 |          number of characters taken by the string (includes space).
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_number(n, min=None) from builtins.type
 |      Given a float number, returns a ""reasonable"" ExpFormat instance to
 |      represent any number between -n and n.
 |      
 |      Parameters
 |      ----------
 |      n : float
 |          max number one wants to be able to represent
 |      min : int
 |          minimum number of characters to use for the format
 |      
 |      Returns
 |      -------
 |      res : ExpFormat
 |          ExpFormat instance with reasonable (see Notes) computed width
 |      
 |      Notes
 |      -----
 |      Reasonable should be understood as the minimal string length necessary
 |      to avoid losing precision.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  fortran_format
 |  
 |  python_format
",class,"('self', 'width', 'significand', 'min', 'repeat')","(nan, nan, nan, None, None)","(nan, nan, nan, 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, width, significand, min=None, repeat=None)',)"
scipy,1.1.0,scipy.io.harwell_boeing._fortran_format_parser.ExpFormat.from_number,io.harwell_boeing._fortran_format_parser.ExpFormat,from_number,"Python Library Documentation: method from_number in module scipy.io.harwell_boeing._fortran_format_parser

from_number(n, min=None) method of builtins.type instance
    Given a float number, returns a ""reasonable"" ExpFormat instance to
    represent any number between -n and n.
    
    Parameters
    ----------
    n : float
        max number one wants to be able to represent
    min : int
        minimum number of characters to use for the format
    
    Returns
    -------
    res : ExpFormat
        ExpFormat instance with reasonable (see Notes) computed width
    
    Notes
    -----
    Reasonable should be understood as the minimal string length necessary
    to avoid losing precision.
",method,"('(n, min=None)',)",scipy,1.1.0,scipy.io.harwell_boeing._fortran_format_parser.ExpFormat.from_number,io.harwell_boeing._fortran_format_parser.ExpFormat,from_number,"Python Library Documentation: method from_number in module scipy.io.harwell_boeing._fortran_format_parser

from_number(n, min=None) method of builtins.type instance
    Given a float number, returns a ""reasonable"" ExpFormat instance to
    represent any number between -n and n.
    
    Parameters
    ----------
    n : float
        max number one wants to be able to represent
    min : int
        minimum number of characters to use for the format
    
    Returns
    -------
    res : ExpFormat
        ExpFormat instance with reasonable (see Notes) computed width
    
    Notes
    -----
    Reasonable should be understood as the minimal string length necessary
    to avoid losing precision.
",method,"('cls', 'n', 'min')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(n, min=None)',)"
scipy,1.1.0,scipy.io.harwell_boeing._fortran_format_parser.FortranFormatParser,io.harwell_boeing._fortran_format_parser,FortranFormatParser,"Python Library Documentation: class FortranFormatParser in module scipy.io.harwell_boeing._fortran_format_parser

class FortranFormatParser(builtins.object)
 |  Parser for fortran format strings. The parse method returns a *Format
 |  instance.
 |  
 |  Notes
 |  -----
 |  Only ExpFormat (exponential format for floating values) and IntFormat
 |  (integer format) for now.
 |  
 |  Methods defined here:
 |  
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  parse(self, s)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self)',)",scipy,1.1.0,scipy.io.harwell_boeing._fortran_format_parser.FortranFormatParser,io.harwell_boeing._fortran_format_parser,FortranFormatParser,"Python Library Documentation: class FortranFormatParser in module scipy.io.harwell_boeing._fortran_format_parser

class FortranFormatParser(builtins.object)
 |  Parser for fortran format strings. The parse method returns a *Format
 |  instance.
 |  
 |  Notes
 |  -----
 |  Only ExpFormat (exponential format for floating values) and IntFormat
 |  (integer format) for now.
 |  
 |  Methods defined here:
 |  
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  parse(self, s)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self)',)"
scipy,1.1.0,scipy.io.harwell_boeing._fortran_format_parser.IntFormat,io.harwell_boeing._fortran_format_parser,IntFormat,"Python Library Documentation: class IntFormat in module scipy.io.harwell_boeing._fortran_format_parser

class IntFormat(builtins.object)
 |  Methods defined here:
 |  
 |  __init__(self, width, min=None, repeat=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_number(n, min=None) from builtins.type
 |      Given an integer, returns a ""reasonable"" IntFormat instance to represent
 |      any number between 0 and n if n > 0, -n and n if n < 0
 |      
 |      Parameters
 |      ----------
 |      n : int
 |          max number one wants to be able to represent
 |      min : int
 |          minimum number of characters to use for the format
 |      
 |      Returns
 |      -------
 |      res : IntFormat
 |          IntFormat instance with reasonable (see Notes) computed width
 |      
 |      Notes
 |      -----
 |      Reasonable should be understood as the minimal string length necessary
 |      without losing precision. For example, IntFormat.from_number(1) will
 |      return an IntFormat instance of width 2, so that any 0 and 1 may be
 |      represented as 1-character strings without loss of information.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  fortran_format
 |  
 |  python_format
",class,"('(self, width, min=None, repeat=None)',)",scipy,1.1.0,scipy.io.harwell_boeing._fortran_format_parser.IntFormat,io.harwell_boeing._fortran_format_parser,IntFormat,"Python Library Documentation: class IntFormat in module scipy.io.harwell_boeing._fortran_format_parser

class IntFormat(builtins.object)
 |  Methods defined here:
 |  
 |  __init__(self, width, min=None, repeat=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_number(n, min=None) from builtins.type
 |      Given an integer, returns a ""reasonable"" IntFormat instance to represent
 |      any number between 0 and n if n > 0, -n and n if n < 0
 |      
 |      Parameters
 |      ----------
 |      n : int
 |          max number one wants to be able to represent
 |      min : int
 |          minimum number of characters to use for the format
 |      
 |      Returns
 |      -------
 |      res : IntFormat
 |          IntFormat instance with reasonable (see Notes) computed width
 |      
 |      Notes
 |      -----
 |      Reasonable should be understood as the minimal string length necessary
 |      without losing precision. For example, IntFormat.from_number(1) will
 |      return an IntFormat instance of width 2, so that any 0 and 1 may be
 |      represented as 1-character strings without loss of information.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  fortran_format
 |  
 |  python_format
",class,"('self', 'width', 'min', 'repeat')","(nan, nan, None, None)","(nan, nan, 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, width, min=None, repeat=None)',)"
scipy,1.1.0,scipy.io.harwell_boeing._fortran_format_parser.IntFormat.from_number,io.harwell_boeing._fortran_format_parser.IntFormat,from_number,"Python Library Documentation: method from_number in module scipy.io.harwell_boeing._fortran_format_parser

from_number(n, min=None) method of builtins.type instance
    Given an integer, returns a ""reasonable"" IntFormat instance to represent
    any number between 0 and n if n > 0, -n and n if n < 0
    
    Parameters
    ----------
    n : int
        max number one wants to be able to represent
    min : int
        minimum number of characters to use for the format
    
    Returns
    -------
    res : IntFormat
        IntFormat instance with reasonable (see Notes) computed width
    
    Notes
    -----
    Reasonable should be understood as the minimal string length necessary
    without losing precision. For example, IntFormat.from_number(1) will
    return an IntFormat instance of width 2, so that any 0 and 1 may be
    represented as 1-character strings without loss of information.
",method,"('(n, min=None)',)",scipy,1.1.0,scipy.io.harwell_boeing._fortran_format_parser.IntFormat.from_number,io.harwell_boeing._fortran_format_parser.IntFormat,from_number,"Python Library Documentation: method from_number in module scipy.io.harwell_boeing._fortran_format_parser

from_number(n, min=None) method of builtins.type instance
    Given an integer, returns a ""reasonable"" IntFormat instance to represent
    any number between 0 and n if n > 0, -n and n if n < 0
    
    Parameters
    ----------
    n : int
        max number one wants to be able to represent
    min : int
        minimum number of characters to use for the format
    
    Returns
    -------
    res : IntFormat
        IntFormat instance with reasonable (see Notes) computed width
    
    Notes
    -----
    Reasonable should be understood as the minimal string length necessary
    without losing precision. For example, IntFormat.from_number(1) will
    return an IntFormat instance of width 2, so that any 0 and 1 may be
    represented as 1-character strings without loss of information.
",method,"('cls', 'n', 'min')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(n, min=None)',)"
scipy,1.1.0,scipy.io.harwell_boeing._fortran_format_parser.Token,io.harwell_boeing._fortran_format_parser,Token,"Python Library Documentation: class Token in module scipy.io.harwell_boeing._fortran_format_parser

class Token(builtins.object)
 |  Methods defined here:
 |  
 |  __init__(self, type, value, pos)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __str__(self)
 |      Return str(self).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, type, value, pos)',)",scipy,1.1.0,scipy.io.harwell_boeing._fortran_format_parser.Token,io.harwell_boeing._fortran_format_parser,Token,"Python Library Documentation: class Token in module scipy.io.harwell_boeing._fortran_format_parser

class Token(builtins.object)
 |  Methods defined here:
 |  
 |  __init__(self, type, value, pos)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __str__(self)
 |      Return str(self).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'type', 'value', 'pos')","(nan, nan, nan, nan)","(nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, type, value, pos)',)"
scipy,1.1.0,scipy.io.harwell_boeing._fortran_format_parser.Tokenizer,io.harwell_boeing._fortran_format_parser,Tokenizer,"Python Library Documentation: class Tokenizer in module scipy.io.harwell_boeing._fortran_format_parser

class Tokenizer(builtins.object)
 |  Methods defined here:
 |  
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  input(self, s)
 |  
 |  next_token(self)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self)',)",scipy,1.1.0,scipy.io.harwell_boeing._fortran_format_parser.Tokenizer,io.harwell_boeing._fortran_format_parser,Tokenizer,"Python Library Documentation: class Tokenizer in module scipy.io.harwell_boeing._fortran_format_parser

class Tokenizer(builtins.object)
 |  Methods defined here:
 |  
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  input(self, s)
 |  
 |  next_token(self)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self)',)"
scipy,1.1.0,scipy.io.harwell_boeing._fortran_format_parser.number_digits,io.harwell_boeing._fortran_format_parser,number_digits,"Python Library Documentation: function number_digits in module scipy.io.harwell_boeing._fortran_format_parser

number_digits(n)
",function,"('(n)',)",scipy,1.1.0,scipy.io.harwell_boeing._fortran_format_parser.number_digits,io.harwell_boeing._fortran_format_parser,number_digits,"Python Library Documentation: function number_digits in module scipy.io.harwell_boeing._fortran_format_parser

number_digits(n)
",function,"('n',)","(nan,)","(nan,)","('arg_info',)","('(n)',)"
scipy,1.1.0,scipy.io.harwell_boeing.hb.ExpFormat,io.harwell_boeing.hb,ExpFormat,"Python Library Documentation: class ExpFormat in module scipy.io.harwell_boeing._fortran_format_parser

class ExpFormat(builtins.object)
 |  Methods defined here:
 |  
 |  __init__(self, width, significand, min=None, repeat=None)
 |      Parameters
 |      ----------
 |      width : int
 |          number of characters taken by the string (includes space).
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_number(n, min=None) from builtins.type
 |      Given a float number, returns a ""reasonable"" ExpFormat instance to
 |      represent any number between -n and n.
 |      
 |      Parameters
 |      ----------
 |      n : float
 |          max number one wants to be able to represent
 |      min : int
 |          minimum number of characters to use for the format
 |      
 |      Returns
 |      -------
 |      res : ExpFormat
 |          ExpFormat instance with reasonable (see Notes) computed width
 |      
 |      Notes
 |      -----
 |      Reasonable should be understood as the minimal string length necessary
 |      to avoid losing precision.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  fortran_format
 |  
 |  python_format
",class,"('(self, width, significand, min=None, repeat=None)',)",scipy,1.1.0,scipy.io.harwell_boeing.hb.ExpFormat,io.harwell_boeing.hb,ExpFormat,"Python Library Documentation: class ExpFormat in module scipy.io.harwell_boeing._fortran_format_parser

class ExpFormat(builtins.object)
 |  Methods defined here:
 |  
 |  __init__(self, width, significand, min=None, repeat=None)
 |      Parameters
 |      ----------
 |      width : int
 |          number of characters taken by the string (includes space).
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_number(n, min=None) from builtins.type
 |      Given a float number, returns a ""reasonable"" ExpFormat instance to
 |      represent any number between -n and n.
 |      
 |      Parameters
 |      ----------
 |      n : float
 |          max number one wants to be able to represent
 |      min : int
 |          minimum number of characters to use for the format
 |      
 |      Returns
 |      -------
 |      res : ExpFormat
 |          ExpFormat instance with reasonable (see Notes) computed width
 |      
 |      Notes
 |      -----
 |      Reasonable should be understood as the minimal string length necessary
 |      to avoid losing precision.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  fortran_format
 |  
 |  python_format
",class,"('self', 'width', 'significand', 'min', 'repeat')","(nan, nan, nan, None, None)","(nan, nan, nan, 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, width, significand, min=None, repeat=None)',)"
scipy,1.1.0,scipy.io.harwell_boeing.hb.ExpFormat.from_number,io.harwell_boeing.hb.ExpFormat,from_number,"Python Library Documentation: method from_number in module scipy.io.harwell_boeing._fortran_format_parser

from_number(n, min=None) method of builtins.type instance
    Given a float number, returns a ""reasonable"" ExpFormat instance to
    represent any number between -n and n.
    
    Parameters
    ----------
    n : float
        max number one wants to be able to represent
    min : int
        minimum number of characters to use for the format
    
    Returns
    -------
    res : ExpFormat
        ExpFormat instance with reasonable (see Notes) computed width
    
    Notes
    -----
    Reasonable should be understood as the minimal string length necessary
    to avoid losing precision.
",method,"('(n, min=None)',)",scipy,1.1.0,scipy.io.harwell_boeing.hb.ExpFormat.from_number,io.harwell_boeing.hb.ExpFormat,from_number,"Python Library Documentation: method from_number in module scipy.io.harwell_boeing._fortran_format_parser

from_number(n, min=None) method of builtins.type instance
    Given a float number, returns a ""reasonable"" ExpFormat instance to
    represent any number between -n and n.
    
    Parameters
    ----------
    n : float
        max number one wants to be able to represent
    min : int
        minimum number of characters to use for the format
    
    Returns
    -------
    res : ExpFormat
        ExpFormat instance with reasonable (see Notes) computed width
    
    Notes
    -----
    Reasonable should be understood as the minimal string length necessary
    to avoid losing precision.
",method,"('cls', 'n', 'min')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(n, min=None)',)"
scipy,1.1.0,scipy.io.harwell_boeing.hb.FortranFormatParser,io.harwell_boeing.hb,FortranFormatParser,"Python Library Documentation: class FortranFormatParser in module scipy.io.harwell_boeing._fortran_format_parser

class FortranFormatParser(builtins.object)
 |  Parser for fortran format strings. The parse method returns a *Format
 |  instance.
 |  
 |  Notes
 |  -----
 |  Only ExpFormat (exponential format for floating values) and IntFormat
 |  (integer format) for now.
 |  
 |  Methods defined here:
 |  
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  parse(self, s)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self)',)",scipy,1.1.0,scipy.io.harwell_boeing.hb.FortranFormatParser,io.harwell_boeing.hb,FortranFormatParser,"Python Library Documentation: class FortranFormatParser in module scipy.io.harwell_boeing._fortran_format_parser

class FortranFormatParser(builtins.object)
 |  Parser for fortran format strings. The parse method returns a *Format
 |  instance.
 |  
 |  Notes
 |  -----
 |  Only ExpFormat (exponential format for floating values) and IntFormat
 |  (integer format) for now.
 |  
 |  Methods defined here:
 |  
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  parse(self, s)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self)',)"
scipy,1.1.0,scipy.io.harwell_boeing.hb.HBFile,io.harwell_boeing.hb,HBFile,"Python Library Documentation: class HBFile in module scipy.io.harwell_boeing.hb

class HBFile(builtins.object)
 |  Methods defined here:
 |  
 |  __init__(self, file, hb_info=None)
 |      Create a HBFile instance.
 |      
 |      Parameters
 |      ----------
 |      file : file-object
 |          StringIO work as well
 |      hb_info : HBInfo, optional
 |          Should be given as an argument for writing, in which case the file
 |          should be writable.
 |  
 |  read_matrix(self)
 |  
 |  write_matrix(self, m)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  key
 |  
 |  storage
 |  
 |  structure
 |  
 |  title
 |  
 |  type
",class,"('(self, file, hb_info=None)',)",scipy,1.1.0,scipy.io.harwell_boeing.hb.HBFile,io.harwell_boeing.hb,HBFile,"Python Library Documentation: class HBFile in module scipy.io.harwell_boeing.hb

class HBFile(builtins.object)
 |  Methods defined here:
 |  
 |  __init__(self, file, hb_info=None)
 |      Create a HBFile instance.
 |      
 |      Parameters
 |      ----------
 |      file : file-object
 |          StringIO work as well
 |      hb_info : HBInfo, optional
 |          Should be given as an argument for writing, in which case the file
 |          should be writable.
 |  
 |  read_matrix(self)
 |  
 |  write_matrix(self, m)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  key
 |  
 |  storage
 |  
 |  structure
 |  
 |  title
 |  
 |  type
",class,"('self', 'file', 'hb_info')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(self, file, hb_info=None)',)"
scipy,1.1.0,scipy.io.harwell_boeing.hb.HBInfo,io.harwell_boeing.hb,HBInfo,"Python Library Documentation: class HBInfo in module scipy.io.harwell_boeing.hb

class HBInfo(builtins.object)
 |  Methods defined here:
 |  
 |  __init__(self, title, key, total_nlines, pointer_nlines, indices_nlines, values_nlines, mxtype, nrows, ncols, nnon_zeros, pointer_format_str, indices_format_str, values_format_str, right_hand_sides_nlines=0, nelementals=0)
 |      Do not use this directly, but the class ctrs (from_* functions).
 |  
 |  dump(self)
 |      Gives the header corresponding to this instance as a string.
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_data(m, title='Default title', key='0', mxtype=None, fmt=None) from builtins.type
 |      Create a HBInfo instance from an existing sparse matrix.
 |      
 |      Parameters
 |      ----------
 |      m : sparse matrix
 |          the HBInfo instance will derive its parameters from m
 |      title : str
 |          Title to put in the HB header
 |      key : str
 |          Key
 |      mxtype : HBMatrixType
 |          type of the input matrix
 |      fmt : dict
 |          not implemented
 |      
 |      Returns
 |      -------
 |      hb_info : HBInfo instance
 |  
 |  from_file(fid) from builtins.type
 |      Create a HBInfo instance from a file object containing a matrix in the
 |      HB format.
 |      
 |      Parameters
 |      ----------
 |      fid : file-like matrix
 |          File or file-like object containing a matrix in the HB format.
 |      
 |      Returns
 |      -------
 |      hb_info : HBInfo instance
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, title, key, total_nlines, pointer_nlines, indices_nlines, values_nlines, mxtype, nrows, ncols, nnon_zeros, pointer_format_str, indices_format_str, values_format_str, right_hand_sides_nlines=0, nelementals=0)',)",scipy,1.1.0,scipy.io.harwell_boeing.hb.HBInfo,io.harwell_boeing.hb,HBInfo,"Python Library Documentation: class HBInfo in module scipy.io.harwell_boeing.hb

class HBInfo(builtins.object)
 |  Methods defined here:
 |  
 |  __init__(self, title, key, total_nlines, pointer_nlines, indices_nlines, values_nlines, mxtype, nrows, ncols, nnon_zeros, pointer_format_str, indices_format_str, values_format_str, right_hand_sides_nlines=0, nelementals=0)
 |      Do not use this directly, but the class ctrs (from_* functions).
 |  
 |  dump(self)
 |      Gives the header corresponding to this instance as a string.
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_data(m, title='Default title', key='0', mxtype=None, fmt=None) from builtins.type
 |      Create a HBInfo instance from an existing sparse matrix.
 |      
 |      Parameters
 |      ----------
 |      m : sparse matrix
 |          the HBInfo instance will derive its parameters from m
 |      title : str
 |          Title to put in the HB header
 |      key : str
 |          Key
 |      mxtype : HBMatrixType
 |          type of the input matrix
 |      fmt : dict
 |          not implemented
 |      
 |      Returns
 |      -------
 |      hb_info : HBInfo instance
 |  
 |  from_file(fid) from builtins.type
 |      Create a HBInfo instance from a file object containing a matrix in the
 |      HB format.
 |      
 |      Parameters
 |      ----------
 |      fid : file-like matrix
 |          File or file-like object containing a matrix in the HB format.
 |      
 |      Returns
 |      -------
 |      hb_info : HBInfo instance
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'title', 'key', 'total_nlines', 'pointer_nlines', 'indices_nlines', 'values_nlines', 'mxtype', 'nrows', 'ncols', 'nnon_zeros', 'pointer_format_str', 'indices_format_str', 'values_format_str', 'right_hand_sides_nlines', 'nelementals')","(nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, 0, 0)","(nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, 'int', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, title, key, total_nlines, pointer_nlines, indices_nlines, values_nlines, mxtype, nrows, ncols, nnon_zeros, pointer_format_str, indices_format_str, values_format_str, right_hand_sides_nlines=0, nelementals=0)',)"
scipy,1.1.0,scipy.io.harwell_boeing.hb.HBInfo.from_data,io.harwell_boeing.hb.HBInfo,from_data,"Python Library Documentation: method from_data in module scipy.io.harwell_boeing.hb

from_data(m, title='Default title', key='0', mxtype=None, fmt=None) method of builtins.type instance
    Create a HBInfo instance from an existing sparse matrix.
    
    Parameters
    ----------
    m : sparse matrix
        the HBInfo instance will derive its parameters from m
    title : str
        Title to put in the HB header
    key : str
        Key
    mxtype : HBMatrixType
        type of the input matrix
    fmt : dict
        not implemented
    
    Returns
    -------
    hb_info : HBInfo instance
",method,"(""(m, title='Default title', key='0', mxtype=None, fmt=None)"",)",scipy,1.1.0,scipy.io.harwell_boeing.hb.HBInfo.from_data,io.harwell_boeing.hb.HBInfo,from_data,"Python Library Documentation: method from_data in module scipy.io.harwell_boeing.hb

from_data(m, title='Default title', key='0', mxtype=None, fmt=None) method of builtins.type instance
    Create a HBInfo instance from an existing sparse matrix.
    
    Parameters
    ----------
    m : sparse matrix
        the HBInfo instance will derive its parameters from m
    title : str
        Title to put in the HB header
    key : str
        Key
    mxtype : HBMatrixType
        type of the input matrix
    fmt : dict
        not implemented
    
    Returns
    -------
    hb_info : HBInfo instance
",method,"('cls', 'm', 'title', 'key', 'mxtype', 'fmt')","(nan, nan, 'Default title', '0', None, None)","(nan, nan, nan, 'int', 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(m, title='Default title', key='0', mxtype=None, fmt=None)"",)"
scipy,1.1.0,scipy.io.harwell_boeing.hb.HBInfo.from_file,io.harwell_boeing.hb.HBInfo,from_file,"Python Library Documentation: method from_file in module scipy.io.harwell_boeing.hb

from_file(fid) method of builtins.type instance
    Create a HBInfo instance from a file object containing a matrix in the
    HB format.
    
    Parameters
    ----------
    fid : file-like matrix
        File or file-like object containing a matrix in the HB format.
    
    Returns
    -------
    hb_info : HBInfo instance
",method,"('(fid)',)",scipy,1.1.0,scipy.io.harwell_boeing.hb.HBInfo.from_file,io.harwell_boeing.hb.HBInfo,from_file,"Python Library Documentation: method from_file in module scipy.io.harwell_boeing.hb

from_file(fid) method of builtins.type instance
    Create a HBInfo instance from a file object containing a matrix in the
    HB format.
    
    Parameters
    ----------
    fid : file-like matrix
        File or file-like object containing a matrix in the HB format.
    
    Returns
    -------
    hb_info : HBInfo instance
",method,"('cls', 'fid')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(fid)',)"
scipy,1.1.0,scipy.io.harwell_boeing.hb.HBMatrixType,io.harwell_boeing.hb,HBMatrixType,"Python Library Documentation: class HBMatrixType in module scipy.io.harwell_boeing.hb

class HBMatrixType(builtins.object)
 |  Class to hold the matrix type.
 |  
 |  Methods defined here:
 |  
 |  __init__(self, value_type, structure, storage='assembled')
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_fortran(fmt) from builtins.type
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  fortran_format
",class,"(""(self, value_type, structure, storage='assembled')"",)",scipy,1.1.0,scipy.io.harwell_boeing.hb.HBMatrixType,io.harwell_boeing.hb,HBMatrixType,"Python Library Documentation: class HBMatrixType in module scipy.io.harwell_boeing.hb

class HBMatrixType(builtins.object)
 |  Class to hold the matrix type.
 |  
 |  Methods defined here:
 |  
 |  __init__(self, value_type, structure, storage='assembled')
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_fortran(fmt) from builtins.type
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  fortran_format
",class,"('self', 'value_type', 'structure', 'storage')","(nan, nan, nan, 'assembled')","(nan, nan, nan, 'str')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(self, value_type, structure, storage='assembled')"",)"
scipy,1.1.0,scipy.io.harwell_boeing.hb.HBMatrixType.from_fortran,io.harwell_boeing.hb.HBMatrixType,from_fortran,"Python Library Documentation: method from_fortran in module scipy.io.harwell_boeing.hb

from_fortran(fmt) method of builtins.type instance
",method,"('(fmt)',)",scipy,1.1.0,scipy.io.harwell_boeing.hb.HBMatrixType.from_fortran,io.harwell_boeing.hb.HBMatrixType,from_fortran,"Python Library Documentation: method from_fortran in module scipy.io.harwell_boeing.hb

from_fortran(fmt) method of builtins.type instance
",method,"('cls', 'fmt')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(fmt)',)"
scipy,1.1.0,scipy.io.harwell_boeing.hb.IntFormat,io.harwell_boeing.hb,IntFormat,"Python Library Documentation: class IntFormat in module scipy.io.harwell_boeing._fortran_format_parser

class IntFormat(builtins.object)
 |  Methods defined here:
 |  
 |  __init__(self, width, min=None, repeat=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_number(n, min=None) from builtins.type
 |      Given an integer, returns a ""reasonable"" IntFormat instance to represent
 |      any number between 0 and n if n > 0, -n and n if n < 0
 |      
 |      Parameters
 |      ----------
 |      n : int
 |          max number one wants to be able to represent
 |      min : int
 |          minimum number of characters to use for the format
 |      
 |      Returns
 |      -------
 |      res : IntFormat
 |          IntFormat instance with reasonable (see Notes) computed width
 |      
 |      Notes
 |      -----
 |      Reasonable should be understood as the minimal string length necessary
 |      without losing precision. For example, IntFormat.from_number(1) will
 |      return an IntFormat instance of width 2, so that any 0 and 1 may be
 |      represented as 1-character strings without loss of information.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  fortran_format
 |  
 |  python_format
",class,"('(self, width, min=None, repeat=None)',)",scipy,1.1.0,scipy.io.harwell_boeing.hb.IntFormat,io.harwell_boeing.hb,IntFormat,"Python Library Documentation: class IntFormat in module scipy.io.harwell_boeing._fortran_format_parser

class IntFormat(builtins.object)
 |  Methods defined here:
 |  
 |  __init__(self, width, min=None, repeat=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_number(n, min=None) from builtins.type
 |      Given an integer, returns a ""reasonable"" IntFormat instance to represent
 |      any number between 0 and n if n > 0, -n and n if n < 0
 |      
 |      Parameters
 |      ----------
 |      n : int
 |          max number one wants to be able to represent
 |      min : int
 |          minimum number of characters to use for the format
 |      
 |      Returns
 |      -------
 |      res : IntFormat
 |          IntFormat instance with reasonable (see Notes) computed width
 |      
 |      Notes
 |      -----
 |      Reasonable should be understood as the minimal string length necessary
 |      without losing precision. For example, IntFormat.from_number(1) will
 |      return an IntFormat instance of width 2, so that any 0 and 1 may be
 |      represented as 1-character strings without loss of information.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  fortran_format
 |  
 |  python_format
",class,"('self', 'width', 'min', 'repeat')","(nan, nan, None, None)","(nan, nan, 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, width, min=None, repeat=None)',)"
scipy,1.1.0,scipy.io.harwell_boeing.hb.IntFormat.from_number,io.harwell_boeing.hb.IntFormat,from_number,"Python Library Documentation: method from_number in module scipy.io.harwell_boeing._fortran_format_parser

from_number(n, min=None) method of builtins.type instance
    Given an integer, returns a ""reasonable"" IntFormat instance to represent
    any number between 0 and n if n > 0, -n and n if n < 0
    
    Parameters
    ----------
    n : int
        max number one wants to be able to represent
    min : int
        minimum number of characters to use for the format
    
    Returns
    -------
    res : IntFormat
        IntFormat instance with reasonable (see Notes) computed width
    
    Notes
    -----
    Reasonable should be understood as the minimal string length necessary
    without losing precision. For example, IntFormat.from_number(1) will
    return an IntFormat instance of width 2, so that any 0 and 1 may be
    represented as 1-character strings without loss of information.
",method,"('(n, min=None)',)",scipy,1.1.0,scipy.io.harwell_boeing.hb.IntFormat.from_number,io.harwell_boeing.hb.IntFormat,from_number,"Python Library Documentation: method from_number in module scipy.io.harwell_boeing._fortran_format_parser

from_number(n, min=None) method of builtins.type instance
    Given an integer, returns a ""reasonable"" IntFormat instance to represent
    any number between 0 and n if n > 0, -n and n if n < 0
    
    Parameters
    ----------
    n : int
        max number one wants to be able to represent
    min : int
        minimum number of characters to use for the format
    
    Returns
    -------
    res : IntFormat
        IntFormat instance with reasonable (see Notes) computed width
    
    Notes
    -----
    Reasonable should be understood as the minimal string length necessary
    without losing precision. For example, IntFormat.from_number(1) will
    return an IntFormat instance of width 2, so that any 0 and 1 may be
    represented as 1-character strings without loss of information.
",method,"('cls', 'n', 'min')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(n, min=None)',)"
scipy,1.1.0,scipy.io.harwell_boeing.hb.LineOverflow,io.harwell_boeing.hb,LineOverflow,"Python Library Documentation: class LineOverflow in module scipy.io.harwell_boeing.hb

class LineOverflow(builtins.Warning)
 |  Base class for warning categories.
 |  
 |  Method resolution order:
 |      LineOverflow
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Warning:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.harwell_boeing.hb.LineOverflow,io.harwell_boeing.hb,LineOverflow,"Python Library Documentation: class LineOverflow in module scipy.io.harwell_boeing.hb

class LineOverflow(builtins.Warning)
 |  Base class for warning categories.
 |  
 |  Method resolution order:
 |      LineOverflow
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Warning:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.harwell_boeing.hb.MalformedHeader,io.harwell_boeing.hb,MalformedHeader,"Python Library Documentation: class MalformedHeader in module scipy.io.harwell_boeing.hb

class MalformedHeader(builtins.Exception)
 |  Common base class for all non-exit exceptions.
 |  
 |  Method resolution order:
 |      MalformedHeader
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.harwell_boeing.hb.MalformedHeader,io.harwell_boeing.hb,MalformedHeader,"Python Library Documentation: class MalformedHeader in module scipy.io.harwell_boeing.hb

class MalformedHeader(builtins.Exception)
 |  Common base class for all non-exit exceptions.
 |  
 |  Method resolution order:
 |      MalformedHeader
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.harwell_boeing.hb._expect_int,io.harwell_boeing.hb,_expect_int,"Python Library Documentation: function _expect_int in module scipy.io.harwell_boeing.hb

_expect_int(value, msg=None)
",function,"('(value, msg=None)',)",scipy,1.1.0,scipy.io.harwell_boeing.hb._expect_int,io.harwell_boeing.hb,_expect_int,"Python Library Documentation: function _expect_int in module scipy.io.harwell_boeing.hb

_expect_int(value, msg=None)
",function,"('value', 'msg')","(nan, None)","(nan, 'NoneType')","('arg_info', 'arg_info')","('(value, msg=None)',)"
scipy,1.1.0,scipy.io.harwell_boeing.hb._nbytes_full,io.harwell_boeing.hb,_nbytes_full,"Python Library Documentation: function _nbytes_full in module scipy.io.harwell_boeing.hb

_nbytes_full(fmt, nlines)
    Return the number of bytes to read to get every full lines for the
    given parsed fortran format.
",function,"('(fmt, nlines)',)",scipy,1.1.0,scipy.io.harwell_boeing.hb._nbytes_full,io.harwell_boeing.hb,_nbytes_full,"Python Library Documentation: function _nbytes_full in module scipy.io.harwell_boeing.hb

_nbytes_full(fmt, nlines)
    Return the number of bytes to read to get every full lines for the
    given parsed fortran format.
",function,"('fmt', 'nlines')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(fmt, nlines)',)"
scipy,1.1.0,scipy.io.harwell_boeing.hb._read_hb_data,io.harwell_boeing.hb,_read_hb_data,"Python Library Documentation: function _read_hb_data in module scipy.io.harwell_boeing.hb

_read_hb_data(content, header)
",function,"('(content, header)',)",scipy,1.1.0,scipy.io.harwell_boeing.hb._read_hb_data,io.harwell_boeing.hb,_read_hb_data,"Python Library Documentation: function _read_hb_data in module scipy.io.harwell_boeing.hb

_read_hb_data(content, header)
",function,"('content', 'header')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(content, header)',)"
scipy,1.1.0,scipy.io.harwell_boeing.hb._write_data,io.harwell_boeing.hb,_write_data,"Python Library Documentation: function _write_data in module scipy.io.harwell_boeing.hb

_write_data(m, fid, header)
",function,"('(m, fid, header)',)",scipy,1.1.0,scipy.io.harwell_boeing.hb._write_data,io.harwell_boeing.hb,_write_data,"Python Library Documentation: function _write_data in module scipy.io.harwell_boeing.hb

_write_data(m, fid, header)
",function,"('m', 'fid', 'header')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(m, fid, header)',)"
scipy,1.1.0,scipy.io.harwell_boeing.hb.csc_matrix,io.harwell_boeing.hb,csc_matrix,"Python Library Documentation: class csc_matrix in module scipy.sparse.csc

class csc_matrix(scipy.sparse.compressed._cs_matrix, scipy.sparse.sputils.IndexMixin)
 |  Compressed Sparse Column matrix
 |  
 |  This can be instantiated in several ways:
 |  
 |      csc_matrix(D)
 |          with a dense matrix or rank-2 ndarray D
 |  
 |      csc_matrix(S)
 |          with another sparse matrix S (equivalent to S.tocsc())
 |  
 |      csc_matrix((M, N), [dtype])
 |          to construct an empty matrix with shape (M, N)
 |          dtype is optional, defaulting to dtype='d'.
 |  
 |      csc_matrix((data, (row_ind, col_ind)), [shape=(M, N)])
 |          where ``data``, ``row_ind`` and ``col_ind`` satisfy the
 |          relationship ``a[row_ind[k], col_ind[k]] = data[k]``.
 |  
 |      csc_matrix((data, indices, indptr), [shape=(M, N)])
 |          is the standard CSC representation where the row indices for
 |          column i are stored in ``indices[indptr[i]:indptr[i+1]]``
 |          and their corresponding values are stored in
 |          ``data[indptr[i]:indptr[i+1]]``.  If the shape parameter is
 |          not supplied, the matrix dimensions are inferred from
 |          the index arrays.
 |  
 |  Attributes
 |  ----------
 |  dtype : dtype
 |      Data type of the matrix
 |  shape : 2-tuple
 |      Shape of the matrix
 |  ndim : int
 |      Number of dimensions (this is always 2)
 |  nnz
 |      Number of nonzero elements
 |  data
 |      Data array of the matrix
 |  indices
 |      CSC format index array
 |  indptr
 |      CSC format index pointer array
 |  has_sorted_indices
 |      Whether indices are sorted
 |  
 |  Notes
 |  -----
 |  
 |  Sparse matrices can be used in arithmetic operations: they support
 |  addition, subtraction, multiplication, division, and matrix power.
 |  
 |  Advantages of the CSC format
 |      - efficient arithmetic operations CSC + CSC, CSC * CSC, etc.
 |      - efficient column slicing
 |      - fast matrix vector products (CSR, BSR may be faster)
 |  
 |  Disadvantages of the CSC format
 |    - slow row slicing operations (consider CSR)
 |    - changes to the sparsity structure are expensive (consider LIL or DOK)
 |  
 |  
 |  Examples
 |  --------
 |  
 |  >>> import numpy as np
 |  >>> from scipy.sparse import csc_matrix
 |  >>> csc_matrix((3, 4), dtype=np.int8).toarray()
 |  array([[0, 0, 0, 0],
 |         [0, 0, 0, 0],
 |         [0, 0, 0, 0]], dtype=int8)
 |  
 |  >>> row = np.array([0, 2, 2, 0, 1, 2])
 |  >>> col = np.array([0, 0, 1, 2, 2, 2])
 |  >>> data = np.array([1, 2, 3, 4, 5, 6])
 |  >>> csc_matrix((data, (row, col)), shape=(3, 3)).toarray()
 |  array([[1, 0, 4],
 |         [0, 0, 5],
 |         [2, 3, 6]])
 |  
 |  >>> indptr = np.array([0, 2, 3, 6])
 |  >>> indices = np.array([0, 2, 2, 0, 1, 2])
 |  >>> data = np.array([1, 2, 3, 4, 5, 6])
 |  >>> csc_matrix((data, indices, indptr), shape=(3, 3)).toarray()
 |  array([[1, 0, 4],
 |         [0, 0, 5],
 |         [2, 3, 6]])
 |  
 |  Method resolution order:
 |      csc_matrix
 |      scipy.sparse.compressed._cs_matrix
 |      scipy.sparse.data._data_matrix
 |      scipy.sparse.base.spmatrix
 |      scipy.sparse.data._minmax_mixin
 |      scipy.sparse.sputils.IndexMixin
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __getitem__(self, key)
 |  
 |  __iter__(self)
 |  
 |  getcol(self, i)
 |      Returns a copy of column i of the matrix, as a (m x 1)
 |      CSC matrix (column vector).
 |  
 |  getrow(self, i)
 |      Returns a copy of row i of the matrix, as a (1 x n)
 |      CSR matrix (row vector).
 |  
 |  nonzero(self)
 |      nonzero indices
 |      
 |      Returns a tuple of arrays (row,col) containing the indices
 |      of the non-zero elements of the matrix.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1,2,0],[0,0,3],[4,0,5]])
 |      >>> A.nonzero()
 |      (array([0, 0, 1, 2, 2]), array([0, 1, 2, 0, 2]))
 |  
 |  tocsc(self, copy=False)
 |      Convert this matrix to Compressed Sparse Column format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant csc_matrix.
 |  
 |  tocsr(self, copy=False)
 |      Convert this matrix to Compressed Sparse Row format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant csr_matrix.
 |  
 |  transpose(self, axes=None, copy=False)
 |      Reverses the dimensions of the sparse matrix.
 |      
 |      Parameters
 |      ----------
 |      axes : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value.
 |      copy : bool, optional
 |          Indicates whether or not attributes of `self` should be
 |          copied whenever possible. The degree to which attributes
 |          are copied varies depending on the type of sparse matrix
 |          being used.
 |      
 |      Returns
 |      -------
 |      p : `self` with the dimensions reversed.
 |      
 |      See Also
 |      --------
 |      np.matrix.transpose : NumPy's implementation of 'transpose'
 |                            for matrices
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  format = 'csc'
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.compressed._cs_matrix:
 |  
 |  __eq__(self, other)
 |      Return self==value.
 |  
 |  __ge__(self, other)
 |      Return self>=value.
 |  
 |  __gt__(self, other)
 |      Return self>value.
 |  
 |  __init__(self, arg1, shape=None, dtype=None, copy=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __le__(self, other)
 |      Return self<=value.
 |  
 |  __lt__(self, other)
 |      Return self<value.
 |  
 |  __ne__(self, other)
 |      Return self!=value.
 |  
 |  __setitem__(self, index, x)
 |  
 |  check_format(self, full_check=True)
 |      check whether the matrix format is valid
 |      
 |      Parameters
 |      ----------
 |      full_check : bool, optional
 |          If `True`, rigorous check, O(N) operations. Otherwise
 |          basic check, O(1) operations (default True).
 |  
 |  diagonal(self, k=0)
 |      Returns the k-th diagonal of the matrix.
 |      
 |      Parameters
 |      ----------
 |      k : int, optional
 |          Which diagonal to set, corresponding to elements a[i, i+k].
 |          Default: 0 (the main diagonal).
 |      
 |          .. versionadded:: 1.0
 |      
 |      See also
 |      --------
 |      numpy.diagonal : Equivalent numpy function.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> A.diagonal()
 |      array([1, 0, 5])
 |      >>> A.diagonal(k=1)
 |      array([2, 3])
 |  
 |  eliminate_zeros(self)
 |      Remove zero entries from the matrix
 |      
 |      This is an *in place* operation
 |  
 |  getnnz(self, axis=None)
 |      Number of stored values, including explicit zeros.
 |      
 |      Parameters
 |      ----------
 |      axis : None, 0, or 1
 |          Select between the number of values across the whole matrix, in
 |          each column, or in each row.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  maximum(self, other)
 |      Element-wise maximum between this and another matrix.
 |  
 |  minimum(self, other)
 |      Element-wise minimum between this and another matrix.
 |  
 |  multiply(self, other)
 |      Point-wise multiplication by another matrix, vector, or
 |      scalar.
 |  
 |  prune(self)
 |      Remove empty space after all non-zero elements.
 |  
 |  resize(self, *shape)
 |      Resize the matrix in-place to dimensions given by ``shape``
 |      
 |      Any elements that lie within the new shape will remain at the same
 |      indices, while non-zero elements lying outside the new shape are
 |      removed.
 |      
 |      Parameters
 |      ----------
 |      shape : (int, int)
 |          number of rows and columns in the new matrix
 |      
 |      Notes
 |      -----
 |      The semantics are not identical to `numpy.ndarray.resize` or
 |      `numpy.resize`.  Here, the same data will be maintained at each index
 |      before and after reshape, if that index is within the new bounds.  In
 |      numpy, resizing maintains contiguity of the array, moving elements
 |      around in the logical matrix but not within a flattened representation.
 |      
 |      We give no guarantees about whether the underlying data attributes
 |      (arrays, etc.) will be modified in place or replaced with new objects.
 |  
 |  sort_indices(self)
 |      Sort the indices of this matrix *in place*
 |  
 |  sorted_indices(self)
 |      Return a copy of this matrix with sorted indices
 |  
 |  sum(self, axis=None, dtype=None, out=None)
 |      Sum the matrix elements over a given axis.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the sum of all the matrix elements, returning a scalar
 |          (i.e. `axis` = `None`).
 |      dtype : dtype, optional
 |          The type of the returned matrix and of the accumulator in which
 |          the elements are summed.  The dtype of `a` is used by default
 |          unless `a` has an integer dtype of less precision than the default
 |          platform integer.  In that case, if `a` is signed then the platform
 |          integer is used while if `a` is unsigned then an unsigned integer
 |          of the same precision as the platform integer is used.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      sum_along_axis : np.matrix
 |          A matrix with the same shape as `self`, with the specified
 |          axis removed.
 |      
 |      See Also
 |      --------
 |      np.matrix.sum : NumPy's implementation of 'sum' for matrices
 |  
 |  sum_duplicates(self)
 |      Eliminate duplicate matrix entries by adding them together
 |      
 |      The is an *in place* operation
 |  
 |  toarray(self, order=None, out=None)
 |      Return a dense ndarray representation of this matrix.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F'}, optional
 |          Whether to store multi-dimensional data in C (row-major)
 |          or Fortran (column-major) order in memory. The default
 |          is 'None', indicating the NumPy default of C-ordered.
 |          Cannot be specified in conjunction with the `out`
 |          argument.
 |      
 |      out : ndarray, 2-dimensional, optional
 |          If specified, uses this array as the output buffer
 |          instead of allocating a new array to return. The provided
 |          array must have the same shape and dtype as the sparse
 |          matrix on which you are calling the method. For most
 |          sparse types, `out` is required to be memory contiguous
 |          (either C or Fortran ordered).
 |      
 |      Returns
 |      -------
 |      arr : ndarray, 2-dimensional
 |          An array with the same shape and containing the same
 |          data represented by the sparse matrix, with the requested
 |          memory order. If `out` was passed, the same object is
 |          returned after being modified in-place to contain the
 |          appropriate values.
 |  
 |  tocoo(self, copy=True)
 |      Convert this matrix to COOrdinate format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant coo_matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.compressed._cs_matrix:
 |  
 |  has_canonical_format
 |      Determine whether the matrix has sorted indices and no duplicates
 |      
 |      Returns
 |          - True: if the above applies
 |          - False: otherwise
 |      
 |      has_canonical_format implies has_sorted_indices, so if the latter flag
 |      is False, so will the former be; if the former is found True, the
 |      latter flag is also set.
 |  
 |  has_sorted_indices
 |      Determine whether the matrix has sorted indices
 |      
 |      Returns
 |          - True: if the indices of the matrix are in sorted order
 |          - False: otherwise
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.sparse.compressed._cs_matrix:
 |  
 |  __hash__ = None
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._data_matrix:
 |  
 |  __abs__(self)
 |  
 |  __imul__(self, other)
 |  
 |  __itruediv__(self, other)
 |  
 |  __neg__(self)
 |  
 |  arcsin(self)
 |      Element-wise arcsin.
 |      
 |      See numpy.arcsin for more information.
 |  
 |  arcsinh(self)
 |      Element-wise arcsinh.
 |      
 |      See numpy.arcsinh for more information.
 |  
 |  arctan(self)
 |      Element-wise arctan.
 |      
 |      See numpy.arctan for more information.
 |  
 |  arctanh(self)
 |      Element-wise arctanh.
 |      
 |      See numpy.arctanh for more information.
 |  
 |  astype(self, dtype, casting='unsafe', copy=True)
 |      Cast the matrix elements to a specified type.
 |      
 |      Parameters
 |      ----------
 |      dtype : string or numpy dtype
 |          Typecode or data-type to which to cast the data.
 |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
 |          Controls what kind of data casting may occur.
 |          Defaults to 'unsafe' for backwards compatibility.
 |          'no' means the data types should not be cast at all.
 |          'equiv' means only byte-order changes are allowed.
 |          'safe' means only casts which can preserve values are allowed.
 |          'same_kind' means only safe casts or casts within a kind,
 |          like float64 to float32, are allowed.
 |          'unsafe' means any data conversions may be done.
 |      copy : bool, optional
 |          If `copy` is `False`, the result might share some memory with this
 |          matrix. If `copy` is `True`, it is guaranteed that the result and
 |          this matrix do not share any memory.
 |  
 |  ceil(self)
 |      Element-wise ceil.
 |      
 |      See numpy.ceil for more information.
 |  
 |  conj(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  copy(self)
 |      Returns a copy of this matrix.
 |      
 |      No data/indices will be shared between the returned value and current
 |      matrix.
 |  
 |  count_nonzero(self)
 |      Number of non-zero entries, equivalent to
 |      
 |      np.count_nonzero(a.toarray())
 |      
 |      Unlike getnnz() and the nnz property, which return the number of stored
 |      entries (the length of the data attribute), this method counts the
 |      actual number of non-zero entries in data.
 |  
 |  deg2rad(self)
 |      Element-wise deg2rad.
 |      
 |      See numpy.deg2rad for more information.
 |  
 |  expm1(self)
 |      Element-wise expm1.
 |      
 |      See numpy.expm1 for more information.
 |  
 |  floor(self)
 |      Element-wise floor.
 |      
 |      See numpy.floor for more information.
 |  
 |  log1p(self)
 |      Element-wise log1p.
 |      
 |      See numpy.log1p for more information.
 |  
 |  power(self, n, dtype=None)
 |      This function performs element-wise power.
 |      
 |      Parameters
 |      ----------
 |      n : n is a scalar
 |      
 |      dtype : If dtype is not specified, the current dtype will be preserved.
 |  
 |  rad2deg(self)
 |      Element-wise rad2deg.
 |      
 |      See numpy.rad2deg for more information.
 |  
 |  rint(self)
 |      Element-wise rint.
 |      
 |      See numpy.rint for more information.
 |  
 |  sign(self)
 |      Element-wise sign.
 |      
 |      See numpy.sign for more information.
 |  
 |  sin(self)
 |      Element-wise sin.
 |      
 |      See numpy.sin for more information.
 |  
 |  sinh(self)
 |      Element-wise sinh.
 |      
 |      See numpy.sinh for more information.
 |  
 |  sqrt(self)
 |      Element-wise sqrt.
 |      
 |      See numpy.sqrt for more information.
 |  
 |  tan(self)
 |      Element-wise tan.
 |      
 |      See numpy.tan for more information.
 |  
 |  tanh(self)
 |      Element-wise tanh.
 |      
 |      See numpy.tanh for more information.
 |  
 |  trunc(self)
 |      Element-wise trunc.
 |      
 |      See numpy.trunc for more information.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.data._data_matrix:
 |  
 |  dtype
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.base.spmatrix:
 |  
 |  __add__(self, other)
 |  
 |  __bool__(self)
 |  
 |  __div__(self, other)
 |  
 |  __getattr__(self, attr)
 |  
 |  __iadd__(self, other)
 |  
 |  __idiv__(self, other)
 |  
 |  __isub__(self, other)
 |  
 |  __len__(self)
 |      # What should len(sparse) return? For consistency with dense matrices,
 |      # perhaps it should be the number of rows?  But for some uses the number of
 |      # non-zeros is more important.  For now, raise an exception!
 |  
 |  __matmul__(self, other)
 |  
 |  __mul__(self, other)
 |      interpret other and call one of the following
 |      
 |      self._mul_scalar()
 |      self._mul_vector()
 |      self._mul_multivector()
 |      self._mul_sparse_matrix()
 |  
 |  __nonzero__ = __bool__(self)
 |  
 |  __pow__(self, other)
 |  
 |  __radd__(self, other)
 |  
 |  __rdiv__(self, other)
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __rmatmul__(self, other)
 |  
 |  __rmul__(self, other)
 |  
 |  __rsub__(self, other)
 |  
 |  __rtruediv__(self, other)
 |  
 |  __str__(self)
 |      Return str(self).
 |  
 |  __sub__(self, other)
 |  
 |  __truediv__(self, other)
 |  
 |  asformat(self, format, copy=False)
 |      Return this matrix in the passed sparse format.
 |      
 |      Parameters
 |      ----------
 |      format : {str, None}
 |          The desired sparse matrix format (""csr"", ""csc"", ""lil"", ""dok"", ...)
 |          or None for no conversion.
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : This matrix in the passed sparse format.
 |  
 |  asfptype(self)
 |      Upcast matrix to a floating point format (if necessary)
 |  
 |  conjugate(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  dot(self, other)
 |      Ordinary dot product
 |      
 |      Examples
 |      --------
 |      >>> import numpy as np
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> v = np.array([1, 0, -1])
 |      >>> A.dot(v)
 |      array([ 1, -3, -1], dtype=int64)
 |  
 |  getH(self)
 |      Return the Hermitian transpose of this matrix.
 |      
 |      See Also
 |      --------
 |      np.matrix.getH : NumPy's implementation of `getH` for matrices
 |  
 |  get_shape(self)
 |      Get shape of a matrix.
 |  
 |  getformat(self)
 |      Format of a matrix representation as a string.
 |  
 |  getmaxprint(self)
 |      Maximum number of elements to display when printed.
 |  
 |  mean(self, axis=None, dtype=None, out=None)
 |      Compute the arithmetic mean along the specified axis.
 |      
 |      Returns the average of the matrix elements. The average is taken
 |      over all elements in the matrix by default, otherwise over the
 |      specified axis. `float64` intermediate and return values are used
 |      for integer inputs.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the mean is computed. The default is to compute
 |          the mean of all elements in the matrix (i.e. `axis` = `None`).
 |      dtype : data-type, optional
 |          Type to use in computing the mean. For integer inputs, the default
 |          is `float64`; for floating point inputs, it is the same as the
 |          input dtype.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      m : np.matrix
 |      
 |      See Also
 |      --------
 |      np.matrix.mean : NumPy's implementation of 'mean' for matrices
 |  
 |  reshape(self, *args, **kwargs)
 |      reshape(self, shape, order='C', copy=False)
 |      
 |      Gives a new shape to a sparse matrix without changing its data.
 |      
 |      Parameters
 |      ----------
 |      shape : length-2 tuple of ints
 |          The new shape should be compatible with the original shape.
 |      order : {'C', 'F'}, optional
 |          Read the elements using this index order. 'C' means to read and
 |          write the elements using C-like index order; e.g. read entire first
 |          row, then second row, etc. 'F' means to read and write the elements
 |          using Fortran-like index order; e.g. read entire first column, then
 |          second column, etc.
 |      copy : bool, optional
 |          Indicates whether or not attributes of self should be copied
 |          whenever possible. The degree to which attributes are copied varies
 |          depending on the type of sparse matrix being used.
 |      
 |      Returns
 |      -------
 |      reshaped_matrix : sparse matrix
 |          A sparse matrix with the given `shape`, not necessarily of the same
 |          format as the current object.
 |      
 |      See Also
 |      --------
 |      np.matrix.reshape : NumPy's implementation of 'reshape' for matrices
 |  
 |  set_shape(self, shape)
 |      See `reshape`.
 |  
 |  setdiag(self, values, k=0)
 |      Set diagonal or off-diagonal elements of the array.
 |      
 |      Parameters
 |      ----------
 |      values : array_like
 |          New values of the diagonal elements.
 |      
 |          Values may have any length.  If the diagonal is longer than values,
 |          then the remaining diagonal entries will not be set.  If values if
 |          longer than the diagonal, then the remaining values are ignored.
 |      
 |          If a scalar value is given, all of the diagonal is set to it.
 |      
 |      k : int, optional
 |          Which off-diagonal to set, corresponding to elements a[i,i+k].
 |          Default: 0 (the main diagonal).
 |  
 |  tobsr(self, blocksize=None, copy=False)
 |      Convert this matrix to Block Sparse Row format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant bsr_matrix.
 |      
 |      When blocksize=(R, C) is provided, it will be used for construction of
 |      the bsr_matrix.
 |  
 |  todense(self, order=None, out=None)
 |      Return a dense matrix representation of this matrix.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F'}, optional
 |          Whether to store multi-dimensional data in C (row-major)
 |          or Fortran (column-major) order in memory. The default
 |          is 'None', indicating the NumPy default of C-ordered.
 |          Cannot be specified in conjunction with the `out`
 |          argument.
 |      
 |      out : ndarray, 2-dimensional, optional
 |          If specified, uses this array (or `numpy.matrix`) as the
 |          output buffer instead of allocating a new array to
 |          return. The provided array must have the same shape and
 |          dtype as the sparse matrix on which you are calling the
 |          method.
 |      
 |      Returns
 |      -------
 |      arr : numpy.matrix, 2-dimensional
 |          A NumPy matrix object with the same shape and containing
 |          the same data represented by the sparse matrix, with the
 |          requested memory order. If `out` was passed and was an
 |          array (rather than a `numpy.matrix`), it will be filled
 |          with the appropriate values and returned wrapped in a
 |          `numpy.matrix` object that shares the same memory.
 |  
 |  todia(self, copy=False)
 |      Convert this matrix to sparse DIAgonal format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dia_matrix.
 |  
 |  todok(self, copy=False)
 |      Convert this matrix to Dictionary Of Keys format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dok_matrix.
 |  
 |  tolil(self, copy=False)
 |      Convert this matrix to LInked List format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant lil_matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.base.spmatrix:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  nnz
 |      Number of stored values, including explicit zeros.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  shape
 |      Get shape of a matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.sparse.base.spmatrix:
 |  
 |  __array_priority__ = 10.1
 |  
 |  ndim = 2
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._minmax_mixin:
 |  
 |  argmax(self, axis=None, out=None)
 |      Return indices of maximum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several maximum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmax is computed. If None (default), index
 |          of the maximum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      ind : np.matrix or int
 |          Indices of maximum elements. If matrix, its size along `axis` is 1.
 |  
 |  argmin(self, axis=None, out=None)
 |      Return indices of minimum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several minimum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmin is computed. If None (default), index
 |          of the minimum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |       ind : np.matrix or int
 |          Indices of minimum elements. If matrix, its size along `axis` is 1.
 |  
 |  max(self, axis=None, out=None)
 |      Return the maximum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the maximum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amax : coo_matrix or scalar
 |          Maximum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      min : The minimum value of a sparse matrix along a given axis.
 |      np.matrix.max : NumPy's implementation of 'max' for matrices
 |  
 |  min(self, axis=None, out=None)
 |      Return the minimum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the minimum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amin : coo_matrix or scalar
 |          Minimum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      max : The maximum value of a sparse matrix along a given axis.
 |      np.matrix.min : NumPy's implementation of 'min' for matrices
",class,"('(self, arg1, shape=None, dtype=None, copy=False)',)",scipy,1.1.0,scipy.io.harwell_boeing.hb.csc_matrix,io.harwell_boeing.hb,csc_matrix,"Python Library Documentation: class csc_matrix in module scipy.sparse.csc

class csc_matrix(scipy.sparse.compressed._cs_matrix, scipy.sparse.sputils.IndexMixin)
 |  Compressed Sparse Column matrix
 |  
 |  This can be instantiated in several ways:
 |  
 |      csc_matrix(D)
 |          with a dense matrix or rank-2 ndarray D
 |  
 |      csc_matrix(S)
 |          with another sparse matrix S (equivalent to S.tocsc())
 |  
 |      csc_matrix((M, N), [dtype])
 |          to construct an empty matrix with shape (M, N)
 |          dtype is optional, defaulting to dtype='d'.
 |  
 |      csc_matrix((data, (row_ind, col_ind)), [shape=(M, N)])
 |          where ``data``, ``row_ind`` and ``col_ind`` satisfy the
 |          relationship ``a[row_ind[k], col_ind[k]] = data[k]``.
 |  
 |      csc_matrix((data, indices, indptr), [shape=(M, N)])
 |          is the standard CSC representation where the row indices for
 |          column i are stored in ``indices[indptr[i]:indptr[i+1]]``
 |          and their corresponding values are stored in
 |          ``data[indptr[i]:indptr[i+1]]``.  If the shape parameter is
 |          not supplied, the matrix dimensions are inferred from
 |          the index arrays.
 |  
 |  Attributes
 |  ----------
 |  dtype : dtype
 |      Data type of the matrix
 |  shape : 2-tuple
 |      Shape of the matrix
 |  ndim : int
 |      Number of dimensions (this is always 2)
 |  nnz
 |      Number of nonzero elements
 |  data
 |      Data array of the matrix
 |  indices
 |      CSC format index array
 |  indptr
 |      CSC format index pointer array
 |  has_sorted_indices
 |      Whether indices are sorted
 |  
 |  Notes
 |  -----
 |  
 |  Sparse matrices can be used in arithmetic operations: they support
 |  addition, subtraction, multiplication, division, and matrix power.
 |  
 |  Advantages of the CSC format
 |      - efficient arithmetic operations CSC + CSC, CSC * CSC, etc.
 |      - efficient column slicing
 |      - fast matrix vector products (CSR, BSR may be faster)
 |  
 |  Disadvantages of the CSC format
 |    - slow row slicing operations (consider CSR)
 |    - changes to the sparsity structure are expensive (consider LIL or DOK)
 |  
 |  
 |  Examples
 |  --------
 |  
 |  >>> import numpy as np
 |  >>> from scipy.sparse import csc_matrix
 |  >>> csc_matrix((3, 4), dtype=np.int8).toarray()
 |  array([[0, 0, 0, 0],
 |         [0, 0, 0, 0],
 |         [0, 0, 0, 0]], dtype=int8)
 |  
 |  >>> row = np.array([0, 2, 2, 0, 1, 2])
 |  >>> col = np.array([0, 0, 1, 2, 2, 2])
 |  >>> data = np.array([1, 2, 3, 4, 5, 6])
 |  >>> csc_matrix((data, (row, col)), shape=(3, 3)).toarray()
 |  array([[1, 0, 4],
 |         [0, 0, 5],
 |         [2, 3, 6]])
 |  
 |  >>> indptr = np.array([0, 2, 3, 6])
 |  >>> indices = np.array([0, 2, 2, 0, 1, 2])
 |  >>> data = np.array([1, 2, 3, 4, 5, 6])
 |  >>> csc_matrix((data, indices, indptr), shape=(3, 3)).toarray()
 |  array([[1, 0, 4],
 |         [0, 0, 5],
 |         [2, 3, 6]])
 |  
 |  Method resolution order:
 |      csc_matrix
 |      scipy.sparse.compressed._cs_matrix
 |      scipy.sparse.data._data_matrix
 |      scipy.sparse.base.spmatrix
 |      scipy.sparse.data._minmax_mixin
 |      scipy.sparse.sputils.IndexMixin
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __getitem__(self, key)
 |  
 |  __iter__(self)
 |  
 |  getcol(self, i)
 |      Returns a copy of column i of the matrix, as a (m x 1)
 |      CSC matrix (column vector).
 |  
 |  getrow(self, i)
 |      Returns a copy of row i of the matrix, as a (1 x n)
 |      CSR matrix (row vector).
 |  
 |  nonzero(self)
 |      nonzero indices
 |      
 |      Returns a tuple of arrays (row,col) containing the indices
 |      of the non-zero elements of the matrix.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1,2,0],[0,0,3],[4,0,5]])
 |      >>> A.nonzero()
 |      (array([0, 0, 1, 2, 2]), array([0, 1, 2, 0, 2]))
 |  
 |  tocsc(self, copy=False)
 |      Convert this matrix to Compressed Sparse Column format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant csc_matrix.
 |  
 |  tocsr(self, copy=False)
 |      Convert this matrix to Compressed Sparse Row format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant csr_matrix.
 |  
 |  transpose(self, axes=None, copy=False)
 |      Reverses the dimensions of the sparse matrix.
 |      
 |      Parameters
 |      ----------
 |      axes : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value.
 |      copy : bool, optional
 |          Indicates whether or not attributes of `self` should be
 |          copied whenever possible. The degree to which attributes
 |          are copied varies depending on the type of sparse matrix
 |          being used.
 |      
 |      Returns
 |      -------
 |      p : `self` with the dimensions reversed.
 |      
 |      See Also
 |      --------
 |      np.matrix.transpose : NumPy's implementation of 'transpose'
 |                            for matrices
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  format = 'csc'
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.compressed._cs_matrix:
 |  
 |  __eq__(self, other)
 |      Return self==value.
 |  
 |  __ge__(self, other)
 |      Return self>=value.
 |  
 |  __gt__(self, other)
 |      Return self>value.
 |  
 |  __init__(self, arg1, shape=None, dtype=None, copy=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __le__(self, other)
 |      Return self<=value.
 |  
 |  __lt__(self, other)
 |      Return self<value.
 |  
 |  __ne__(self, other)
 |      Return self!=value.
 |  
 |  __setitem__(self, index, x)
 |  
 |  check_format(self, full_check=True)
 |      check whether the matrix format is valid
 |      
 |      Parameters
 |      ----------
 |      full_check : bool, optional
 |          If `True`, rigorous check, O(N) operations. Otherwise
 |          basic check, O(1) operations (default True).
 |  
 |  diagonal(self, k=0)
 |      Returns the k-th diagonal of the matrix.
 |      
 |      Parameters
 |      ----------
 |      k : int, optional
 |          Which diagonal to set, corresponding to elements a[i, i+k].
 |          Default: 0 (the main diagonal).
 |      
 |          .. versionadded:: 1.0
 |      
 |      See also
 |      --------
 |      numpy.diagonal : Equivalent numpy function.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> A.diagonal()
 |      array([1, 0, 5])
 |      >>> A.diagonal(k=1)
 |      array([2, 3])
 |  
 |  eliminate_zeros(self)
 |      Remove zero entries from the matrix
 |      
 |      This is an *in place* operation
 |  
 |  getnnz(self, axis=None)
 |      Number of stored values, including explicit zeros.
 |      
 |      Parameters
 |      ----------
 |      axis : None, 0, or 1
 |          Select between the number of values across the whole matrix, in
 |          each column, or in each row.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  maximum(self, other)
 |      Element-wise maximum between this and another matrix.
 |  
 |  minimum(self, other)
 |      Element-wise minimum between this and another matrix.
 |  
 |  multiply(self, other)
 |      Point-wise multiplication by another matrix, vector, or
 |      scalar.
 |  
 |  prune(self)
 |      Remove empty space after all non-zero elements.
 |  
 |  resize(self, *shape)
 |      Resize the matrix in-place to dimensions given by ``shape``
 |      
 |      Any elements that lie within the new shape will remain at the same
 |      indices, while non-zero elements lying outside the new shape are
 |      removed.
 |      
 |      Parameters
 |      ----------
 |      shape : (int, int)
 |          number of rows and columns in the new matrix
 |      
 |      Notes
 |      -----
 |      The semantics are not identical to `numpy.ndarray.resize` or
 |      `numpy.resize`.  Here, the same data will be maintained at each index
 |      before and after reshape, if that index is within the new bounds.  In
 |      numpy, resizing maintains contiguity of the array, moving elements
 |      around in the logical matrix but not within a flattened representation.
 |      
 |      We give no guarantees about whether the underlying data attributes
 |      (arrays, etc.) will be modified in place or replaced with new objects.
 |  
 |  sort_indices(self)
 |      Sort the indices of this matrix *in place*
 |  
 |  sorted_indices(self)
 |      Return a copy of this matrix with sorted indices
 |  
 |  sum(self, axis=None, dtype=None, out=None)
 |      Sum the matrix elements over a given axis.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the sum of all the matrix elements, returning a scalar
 |          (i.e. `axis` = `None`).
 |      dtype : dtype, optional
 |          The type of the returned matrix and of the accumulator in which
 |          the elements are summed.  The dtype of `a` is used by default
 |          unless `a` has an integer dtype of less precision than the default
 |          platform integer.  In that case, if `a` is signed then the platform
 |          integer is used while if `a` is unsigned then an unsigned integer
 |          of the same precision as the platform integer is used.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      sum_along_axis : np.matrix
 |          A matrix with the same shape as `self`, with the specified
 |          axis removed.
 |      
 |      See Also
 |      --------
 |      np.matrix.sum : NumPy's implementation of 'sum' for matrices
 |  
 |  sum_duplicates(self)
 |      Eliminate duplicate matrix entries by adding them together
 |      
 |      The is an *in place* operation
 |  
 |  toarray(self, order=None, out=None)
 |      Return a dense ndarray representation of this matrix.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F'}, optional
 |          Whether to store multi-dimensional data in C (row-major)
 |          or Fortran (column-major) order in memory. The default
 |          is 'None', indicating the NumPy default of C-ordered.
 |          Cannot be specified in conjunction with the `out`
 |          argument.
 |      
 |      out : ndarray, 2-dimensional, optional
 |          If specified, uses this array as the output buffer
 |          instead of allocating a new array to return. The provided
 |          array must have the same shape and dtype as the sparse
 |          matrix on which you are calling the method. For most
 |          sparse types, `out` is required to be memory contiguous
 |          (either C or Fortran ordered).
 |      
 |      Returns
 |      -------
 |      arr : ndarray, 2-dimensional
 |          An array with the same shape and containing the same
 |          data represented by the sparse matrix, with the requested
 |          memory order. If `out` was passed, the same object is
 |          returned after being modified in-place to contain the
 |          appropriate values.
 |  
 |  tocoo(self, copy=True)
 |      Convert this matrix to COOrdinate format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant coo_matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.compressed._cs_matrix:
 |  
 |  has_canonical_format
 |      Determine whether the matrix has sorted indices and no duplicates
 |      
 |      Returns
 |          - True: if the above applies
 |          - False: otherwise
 |      
 |      has_canonical_format implies has_sorted_indices, so if the latter flag
 |      is False, so will the former be; if the former is found True, the
 |      latter flag is also set.
 |  
 |  has_sorted_indices
 |      Determine whether the matrix has sorted indices
 |      
 |      Returns
 |          - True: if the indices of the matrix are in sorted order
 |          - False: otherwise
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.sparse.compressed._cs_matrix:
 |  
 |  __hash__ = None
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._data_matrix:
 |  
 |  __abs__(self)
 |  
 |  __imul__(self, other)
 |  
 |  __itruediv__(self, other)
 |  
 |  __neg__(self)
 |  
 |  arcsin(self)
 |      Element-wise arcsin.
 |      
 |      See numpy.arcsin for more information.
 |  
 |  arcsinh(self)
 |      Element-wise arcsinh.
 |      
 |      See numpy.arcsinh for more information.
 |  
 |  arctan(self)
 |      Element-wise arctan.
 |      
 |      See numpy.arctan for more information.
 |  
 |  arctanh(self)
 |      Element-wise arctanh.
 |      
 |      See numpy.arctanh for more information.
 |  
 |  astype(self, dtype, casting='unsafe', copy=True)
 |      Cast the matrix elements to a specified type.
 |      
 |      Parameters
 |      ----------
 |      dtype : string or numpy dtype
 |          Typecode or data-type to which to cast the data.
 |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
 |          Controls what kind of data casting may occur.
 |          Defaults to 'unsafe' for backwards compatibility.
 |          'no' means the data types should not be cast at all.
 |          'equiv' means only byte-order changes are allowed.
 |          'safe' means only casts which can preserve values are allowed.
 |          'same_kind' means only safe casts or casts within a kind,
 |          like float64 to float32, are allowed.
 |          'unsafe' means any data conversions may be done.
 |      copy : bool, optional
 |          If `copy` is `False`, the result might share some memory with this
 |          matrix. If `copy` is `True`, it is guaranteed that the result and
 |          this matrix do not share any memory.
 |  
 |  ceil(self)
 |      Element-wise ceil.
 |      
 |      See numpy.ceil for more information.
 |  
 |  conj(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  copy(self)
 |      Returns a copy of this matrix.
 |      
 |      No data/indices will be shared between the returned value and current
 |      matrix.
 |  
 |  count_nonzero(self)
 |      Number of non-zero entries, equivalent to
 |      
 |      np.count_nonzero(a.toarray())
 |      
 |      Unlike getnnz() and the nnz property, which return the number of stored
 |      entries (the length of the data attribute), this method counts the
 |      actual number of non-zero entries in data.
 |  
 |  deg2rad(self)
 |      Element-wise deg2rad.
 |      
 |      See numpy.deg2rad for more information.
 |  
 |  expm1(self)
 |      Element-wise expm1.
 |      
 |      See numpy.expm1 for more information.
 |  
 |  floor(self)
 |      Element-wise floor.
 |      
 |      See numpy.floor for more information.
 |  
 |  log1p(self)
 |      Element-wise log1p.
 |      
 |      See numpy.log1p for more information.
 |  
 |  power(self, n, dtype=None)
 |      This function performs element-wise power.
 |      
 |      Parameters
 |      ----------
 |      n : n is a scalar
 |      
 |      dtype : If dtype is not specified, the current dtype will be preserved.
 |  
 |  rad2deg(self)
 |      Element-wise rad2deg.
 |      
 |      See numpy.rad2deg for more information.
 |  
 |  rint(self)
 |      Element-wise rint.
 |      
 |      See numpy.rint for more information.
 |  
 |  sign(self)
 |      Element-wise sign.
 |      
 |      See numpy.sign for more information.
 |  
 |  sin(self)
 |      Element-wise sin.
 |      
 |      See numpy.sin for more information.
 |  
 |  sinh(self)
 |      Element-wise sinh.
 |      
 |      See numpy.sinh for more information.
 |  
 |  sqrt(self)
 |      Element-wise sqrt.
 |      
 |      See numpy.sqrt for more information.
 |  
 |  tan(self)
 |      Element-wise tan.
 |      
 |      See numpy.tan for more information.
 |  
 |  tanh(self)
 |      Element-wise tanh.
 |      
 |      See numpy.tanh for more information.
 |  
 |  trunc(self)
 |      Element-wise trunc.
 |      
 |      See numpy.trunc for more information.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.data._data_matrix:
 |  
 |  dtype
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.base.spmatrix:
 |  
 |  __add__(self, other)
 |  
 |  __bool__(self)
 |  
 |  __div__(self, other)
 |  
 |  __getattr__(self, attr)
 |  
 |  __iadd__(self, other)
 |  
 |  __idiv__(self, other)
 |  
 |  __isub__(self, other)
 |  
 |  __len__(self)
 |      # What should len(sparse) return? For consistency with dense matrices,
 |      # perhaps it should be the number of rows?  But for some uses the number of
 |      # non-zeros is more important.  For now, raise an exception!
 |  
 |  __matmul__(self, other)
 |  
 |  __mul__(self, other)
 |      interpret other and call one of the following
 |      
 |      self._mul_scalar()
 |      self._mul_vector()
 |      self._mul_multivector()
 |      self._mul_sparse_matrix()
 |  
 |  __nonzero__ = __bool__(self)
 |  
 |  __pow__(self, other)
 |  
 |  __radd__(self, other)
 |  
 |  __rdiv__(self, other)
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __rmatmul__(self, other)
 |  
 |  __rmul__(self, other)
 |  
 |  __rsub__(self, other)
 |  
 |  __rtruediv__(self, other)
 |  
 |  __str__(self)
 |      Return str(self).
 |  
 |  __sub__(self, other)
 |  
 |  __truediv__(self, other)
 |  
 |  asformat(self, format, copy=False)
 |      Return this matrix in the passed sparse format.
 |      
 |      Parameters
 |      ----------
 |      format : {str, None}
 |          The desired sparse matrix format (""csr"", ""csc"", ""lil"", ""dok"", ...)
 |          or None for no conversion.
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : This matrix in the passed sparse format.
 |  
 |  asfptype(self)
 |      Upcast matrix to a floating point format (if necessary)
 |  
 |  conjugate(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  dot(self, other)
 |      Ordinary dot product
 |      
 |      Examples
 |      --------
 |      >>> import numpy as np
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> v = np.array([1, 0, -1])
 |      >>> A.dot(v)
 |      array([ 1, -3, -1], dtype=int64)
 |  
 |  getH(self)
 |      Return the Hermitian transpose of this matrix.
 |      
 |      See Also
 |      --------
 |      np.matrix.getH : NumPy's implementation of `getH` for matrices
 |  
 |  get_shape(self)
 |      Get shape of a matrix.
 |  
 |  getformat(self)
 |      Format of a matrix representation as a string.
 |  
 |  getmaxprint(self)
 |      Maximum number of elements to display when printed.
 |  
 |  mean(self, axis=None, dtype=None, out=None)
 |      Compute the arithmetic mean along the specified axis.
 |      
 |      Returns the average of the matrix elements. The average is taken
 |      over all elements in the matrix by default, otherwise over the
 |      specified axis. `float64` intermediate and return values are used
 |      for integer inputs.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the mean is computed. The default is to compute
 |          the mean of all elements in the matrix (i.e. `axis` = `None`).
 |      dtype : data-type, optional
 |          Type to use in computing the mean. For integer inputs, the default
 |          is `float64`; for floating point inputs, it is the same as the
 |          input dtype.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      m : np.matrix
 |      
 |      See Also
 |      --------
 |      np.matrix.mean : NumPy's implementation of 'mean' for matrices
 |  
 |  reshape(self, *args, **kwargs)
 |      reshape(self, shape, order='C', copy=False)
 |      
 |      Gives a new shape to a sparse matrix without changing its data.
 |      
 |      Parameters
 |      ----------
 |      shape : length-2 tuple of ints
 |          The new shape should be compatible with the original shape.
 |      order : {'C', 'F'}, optional
 |          Read the elements using this index order. 'C' means to read and
 |          write the elements using C-like index order; e.g. read entire first
 |          row, then second row, etc. 'F' means to read and write the elements
 |          using Fortran-like index order; e.g. read entire first column, then
 |          second column, etc.
 |      copy : bool, optional
 |          Indicates whether or not attributes of self should be copied
 |          whenever possible. The degree to which attributes are copied varies
 |          depending on the type of sparse matrix being used.
 |      
 |      Returns
 |      -------
 |      reshaped_matrix : sparse matrix
 |          A sparse matrix with the given `shape`, not necessarily of the same
 |          format as the current object.
 |      
 |      See Also
 |      --------
 |      np.matrix.reshape : NumPy's implementation of 'reshape' for matrices
 |  
 |  set_shape(self, shape)
 |      See `reshape`.
 |  
 |  setdiag(self, values, k=0)
 |      Set diagonal or off-diagonal elements of the array.
 |      
 |      Parameters
 |      ----------
 |      values : array_like
 |          New values of the diagonal elements.
 |      
 |          Values may have any length.  If the diagonal is longer than values,
 |          then the remaining diagonal entries will not be set.  If values if
 |          longer than the diagonal, then the remaining values are ignored.
 |      
 |          If a scalar value is given, all of the diagonal is set to it.
 |      
 |      k : int, optional
 |          Which off-diagonal to set, corresponding to elements a[i,i+k].
 |          Default: 0 (the main diagonal).
 |  
 |  tobsr(self, blocksize=None, copy=False)
 |      Convert this matrix to Block Sparse Row format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant bsr_matrix.
 |      
 |      When blocksize=(R, C) is provided, it will be used for construction of
 |      the bsr_matrix.
 |  
 |  todense(self, order=None, out=None)
 |      Return a dense matrix representation of this matrix.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F'}, optional
 |          Whether to store multi-dimensional data in C (row-major)
 |          or Fortran (column-major) order in memory. The default
 |          is 'None', indicating the NumPy default of C-ordered.
 |          Cannot be specified in conjunction with the `out`
 |          argument.
 |      
 |      out : ndarray, 2-dimensional, optional
 |          If specified, uses this array (or `numpy.matrix`) as the
 |          output buffer instead of allocating a new array to
 |          return. The provided array must have the same shape and
 |          dtype as the sparse matrix on which you are calling the
 |          method.
 |      
 |      Returns
 |      -------
 |      arr : numpy.matrix, 2-dimensional
 |          A NumPy matrix object with the same shape and containing
 |          the same data represented by the sparse matrix, with the
 |          requested memory order. If `out` was passed and was an
 |          array (rather than a `numpy.matrix`), it will be filled
 |          with the appropriate values and returned wrapped in a
 |          `numpy.matrix` object that shares the same memory.
 |  
 |  todia(self, copy=False)
 |      Convert this matrix to sparse DIAgonal format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dia_matrix.
 |  
 |  todok(self, copy=False)
 |      Convert this matrix to Dictionary Of Keys format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dok_matrix.
 |  
 |  tolil(self, copy=False)
 |      Convert this matrix to LInked List format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant lil_matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.base.spmatrix:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  nnz
 |      Number of stored values, including explicit zeros.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  shape
 |      Get shape of a matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.sparse.base.spmatrix:
 |  
 |  __array_priority__ = 10.1
 |  
 |  ndim = 2
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._minmax_mixin:
 |  
 |  argmax(self, axis=None, out=None)
 |      Return indices of maximum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several maximum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmax is computed. If None (default), index
 |          of the maximum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      ind : np.matrix or int
 |          Indices of maximum elements. If matrix, its size along `axis` is 1.
 |  
 |  argmin(self, axis=None, out=None)
 |      Return indices of minimum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several minimum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmin is computed. If None (default), index
 |          of the minimum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |       ind : np.matrix or int
 |          Indices of minimum elements. If matrix, its size along `axis` is 1.
 |  
 |  max(self, axis=None, out=None)
 |      Return the maximum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the maximum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amax : coo_matrix or scalar
 |          Maximum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      min : The minimum value of a sparse matrix along a given axis.
 |      np.matrix.max : NumPy's implementation of 'max' for matrices
 |  
 |  min(self, axis=None, out=None)
 |      Return the minimum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the minimum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amin : coo_matrix or scalar
 |          Minimum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      max : The maximum value of a sparse matrix along a given axis.
 |      np.matrix.min : NumPy's implementation of 'min' for matrices
",class,"('self', 'arg1', 'shape', 'dtype', 'copy')","(nan, nan, None, None, False)","(nan, nan, 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, arg1, shape=None, dtype=None, copy=False)',)"
scipy,1.1.0,scipy.io.harwell_boeing.hb.hb_read,io.harwell_boeing.hb,hb_read,"Python Library Documentation: function hb_read in module scipy.io.harwell_boeing.hb

hb_read(path_or_open_file)
    Read HB-format file.
    
    Parameters
    ----------
    path_or_open_file : path-like or file-like
        If a file-like object, it is used as-is. Otherwise it is opened
        before reading.
    
    Returns
    -------
    data : scipy.sparse.csc_matrix instance
        The data read from the HB file as a sparse matrix.
    
    Notes
    -----
    At the moment not the full Harwell-Boeing format is supported. Supported
    features are:
    
        - assembled, non-symmetric, real matrices
        - integer for pointer/indices
        - exponential format for float values, and int format
",function,"('(path_or_open_file)',)",scipy,1.1.0,scipy.io.harwell_boeing.hb.hb_read,io.harwell_boeing.hb,hb_read,"Python Library Documentation: function hb_read in module scipy.io.harwell_boeing.hb

hb_read(path_or_open_file)
    Read HB-format file.
    
    Parameters
    ----------
    path_or_open_file : path-like or file-like
        If a file-like object, it is used as-is. Otherwise it is opened
        before reading.
    
    Returns
    -------
    data : scipy.sparse.csc_matrix instance
        The data read from the HB file as a sparse matrix.
    
    Notes
    -----
    At the moment not the full Harwell-Boeing format is supported. Supported
    features are:
    
        - assembled, non-symmetric, real matrices
        - integer for pointer/indices
        - exponential format for float values, and int format
",function,"('path_or_open_file',)","(nan,)","(nan,)","('arg_info',)","('(path_or_open_file)',)"
scipy,1.1.0,scipy.io.harwell_boeing.hb.hb_write,io.harwell_boeing.hb,hb_write,"Python Library Documentation: function hb_write in module scipy.io.harwell_boeing.hb

hb_write(path_or_open_file, m, hb_info=None)
    Write HB-format file.
    
    Parameters
    ----------
    path_or_open_file : path-like or file-like
        If a file-like object, it is used as-is. Otherwise it is opened
        before writing.
    m : sparse-matrix
        the sparse matrix to write
    hb_info : HBInfo
        contains the meta-data for write
    
    Returns
    -------
    None
    
    Notes
    -----
    At the moment not the full Harwell-Boeing format is supported. Supported
    features are:
    
        - assembled, non-symmetric, real matrices
        - integer for pointer/indices
        - exponential format for float values, and int format
",function,"('(path_or_open_file, m, hb_info=None)',)",scipy,1.1.0,scipy.io.harwell_boeing.hb.hb_write,io.harwell_boeing.hb,hb_write,"Python Library Documentation: function hb_write in module scipy.io.harwell_boeing.hb

hb_write(path_or_open_file, m, hb_info=None)
    Write HB-format file.
    
    Parameters
    ----------
    path_or_open_file : path-like or file-like
        If a file-like object, it is used as-is. Otherwise it is opened
        before writing.
    m : sparse-matrix
        the sparse matrix to write
    hb_info : HBInfo
        contains the meta-data for write
    
    Returns
    -------
    None
    
    Notes
    -----
    At the moment not the full Harwell-Boeing format is supported. Supported
    features are:
    
        - assembled, non-symmetric, real matrices
        - integer for pointer/indices
        - exponential format for float values, and int format
",function,"('path_or_open_file', 'm', 'hb_info')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(path_or_open_file, m, hb_info=None)',)"
scipy,1.1.0,scipy.io.harwell_boeing.hb_read,io.harwell_boeing,hb_read,"Python Library Documentation: function hb_read in module scipy.io.harwell_boeing.hb

hb_read(path_or_open_file)
    Read HB-format file.
    
    Parameters
    ----------
    path_or_open_file : path-like or file-like
        If a file-like object, it is used as-is. Otherwise it is opened
        before reading.
    
    Returns
    -------
    data : scipy.sparse.csc_matrix instance
        The data read from the HB file as a sparse matrix.
    
    Notes
    -----
    At the moment not the full Harwell-Boeing format is supported. Supported
    features are:
    
        - assembled, non-symmetric, real matrices
        - integer for pointer/indices
        - exponential format for float values, and int format
",function,"('(path_or_open_file)',)",scipy,1.1.0,scipy.io.harwell_boeing.hb_read,io.harwell_boeing,hb_read,"Python Library Documentation: function hb_read in module scipy.io.harwell_boeing.hb

hb_read(path_or_open_file)
    Read HB-format file.
    
    Parameters
    ----------
    path_or_open_file : path-like or file-like
        If a file-like object, it is used as-is. Otherwise it is opened
        before reading.
    
    Returns
    -------
    data : scipy.sparse.csc_matrix instance
        The data read from the HB file as a sparse matrix.
    
    Notes
    -----
    At the moment not the full Harwell-Boeing format is supported. Supported
    features are:
    
        - assembled, non-symmetric, real matrices
        - integer for pointer/indices
        - exponential format for float values, and int format
",function,"('path_or_open_file',)","(nan,)","(nan,)","('arg_info',)","('(path_or_open_file)',)"
scipy,1.1.0,scipy.io.harwell_boeing.hb_write,io.harwell_boeing,hb_write,"Python Library Documentation: function hb_write in module scipy.io.harwell_boeing.hb

hb_write(path_or_open_file, m, hb_info=None)
    Write HB-format file.
    
    Parameters
    ----------
    path_or_open_file : path-like or file-like
        If a file-like object, it is used as-is. Otherwise it is opened
        before writing.
    m : sparse-matrix
        the sparse matrix to write
    hb_info : HBInfo
        contains the meta-data for write
    
    Returns
    -------
    None
    
    Notes
    -----
    At the moment not the full Harwell-Boeing format is supported. Supported
    features are:
    
        - assembled, non-symmetric, real matrices
        - integer for pointer/indices
        - exponential format for float values, and int format
",function,"('(path_or_open_file, m, hb_info=None)',)",scipy,1.1.0,scipy.io.harwell_boeing.hb_write,io.harwell_boeing,hb_write,"Python Library Documentation: function hb_write in module scipy.io.harwell_boeing.hb

hb_write(path_or_open_file, m, hb_info=None)
    Write HB-format file.
    
    Parameters
    ----------
    path_or_open_file : path-like or file-like
        If a file-like object, it is used as-is. Otherwise it is opened
        before writing.
    m : sparse-matrix
        the sparse matrix to write
    hb_info : HBInfo
        contains the meta-data for write
    
    Returns
    -------
    None
    
    Notes
    -----
    At the moment not the full Harwell-Boeing format is supported. Supported
    features are:
    
        - assembled, non-symmetric, real matrices
        - integer for pointer/indices
        - exponential format for float values, and int format
",function,"('path_or_open_file', 'm', 'hb_info')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(path_or_open_file, m, hb_info=None)',)"
scipy,1.1.0,scipy.io.hb_read,io,hb_read,"Python Library Documentation: function hb_read in module scipy.io.harwell_boeing.hb

hb_read(path_or_open_file)
    Read HB-format file.
    
    Parameters
    ----------
    path_or_open_file : path-like or file-like
        If a file-like object, it is used as-is. Otherwise it is opened
        before reading.
    
    Returns
    -------
    data : scipy.sparse.csc_matrix instance
        The data read from the HB file as a sparse matrix.
    
    Notes
    -----
    At the moment not the full Harwell-Boeing format is supported. Supported
    features are:
    
        - assembled, non-symmetric, real matrices
        - integer for pointer/indices
        - exponential format for float values, and int format
",function,"('(path_or_open_file)',)",scipy,1.1.0,scipy.io.hb_read,io,hb_read,"Python Library Documentation: function hb_read in module scipy.io.harwell_boeing.hb

hb_read(path_or_open_file)
    Read HB-format file.
    
    Parameters
    ----------
    path_or_open_file : path-like or file-like
        If a file-like object, it is used as-is. Otherwise it is opened
        before reading.
    
    Returns
    -------
    data : scipy.sparse.csc_matrix instance
        The data read from the HB file as a sparse matrix.
    
    Notes
    -----
    At the moment not the full Harwell-Boeing format is supported. Supported
    features are:
    
        - assembled, non-symmetric, real matrices
        - integer for pointer/indices
        - exponential format for float values, and int format
",function,"('path_or_open_file',)","(nan,)","(nan,)","('arg_info',)","('(path_or_open_file)',)"
scipy,1.1.0,scipy.io.hb_write,io,hb_write,"Python Library Documentation: function hb_write in module scipy.io.harwell_boeing.hb

hb_write(path_or_open_file, m, hb_info=None)
    Write HB-format file.
    
    Parameters
    ----------
    path_or_open_file : path-like or file-like
        If a file-like object, it is used as-is. Otherwise it is opened
        before writing.
    m : sparse-matrix
        the sparse matrix to write
    hb_info : HBInfo
        contains the meta-data for write
    
    Returns
    -------
    None
    
    Notes
    -----
    At the moment not the full Harwell-Boeing format is supported. Supported
    features are:
    
        - assembled, non-symmetric, real matrices
        - integer for pointer/indices
        - exponential format for float values, and int format
",function,"('(path_or_open_file, m, hb_info=None)',)",scipy,1.1.0,scipy.io.hb_write,io,hb_write,"Python Library Documentation: function hb_write in module scipy.io.harwell_boeing.hb

hb_write(path_or_open_file, m, hb_info=None)
    Write HB-format file.
    
    Parameters
    ----------
    path_or_open_file : path-like or file-like
        If a file-like object, it is used as-is. Otherwise it is opened
        before writing.
    m : sparse-matrix
        the sparse matrix to write
    hb_info : HBInfo
        contains the meta-data for write
    
    Returns
    -------
    None
    
    Notes
    -----
    At the moment not the full Harwell-Boeing format is supported. Supported
    features are:
    
        - assembled, non-symmetric, real matrices
        - integer for pointer/indices
        - exponential format for float values, and int format
",function,"('path_or_open_file', 'm', 'hb_info')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(path_or_open_file, m, hb_info=None)',)"
scipy,1.1.0,scipy.io.idl.AttrDict,io.idl,AttrDict,"Python Library Documentation: class AttrDict in module scipy.io.idl

class AttrDict(builtins.dict)
 |  A case-insensitive dictionary with access via item, attribute, and call
 |  notations:
 |  
 |      >>> d = AttrDict()
 |      >>> d['Variable'] = 123
 |      >>> d['Variable']
 |      123
 |      >>> d.Variable
 |      123
 |      >>> d.variable
 |      123
 |      >>> d('VARIABLE')
 |      123
 |  
 |  Method resolution order:
 |      AttrDict
 |      builtins.dict
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __call__ = __getitem__(self, name)
 |  
 |  __getattr__ = __getitem__(self, name)
 |  
 |  __getitem__(self, name)
 |      x.__getitem__(y) <==> x[y]
 |  
 |  __init__(self, init={})
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __setattr__ = __setitem__(self, key, value)
 |  
 |  __setitem__(self, key, value)
 |      Set self[key] to value.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.dict:
 |  
 |  __contains__(self, key, /)
 |      True if D has a key k, else False.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __sizeof__(...)
 |      D.__sizeof__() -> size of D in memory, in bytes
 |  
 |  clear(...)
 |      D.clear() -> None.  Remove all items from D.
 |  
 |  copy(...)
 |      D.copy() -> a shallow copy of D
 |  
 |  fromkeys(iterable, value=None, /) from builtins.type
 |      Returns a new dict with keys from iterable and values equal to value.
 |  
 |  get(...)
 |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
 |  
 |  items(...)
 |      D.items() -> a set-like object providing a view on D's items
 |  
 |  keys(...)
 |      D.keys() -> a set-like object providing a view on D's keys
 |  
 |  pop(...)
 |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
 |      If key is not found, d is returned if given, otherwise KeyError is raised
 |  
 |  popitem(...)
 |      D.popitem() -> (k, v), remove and return some (key, value) pair as a
 |      2-tuple; but raise KeyError if D is empty.
 |  
 |  setdefault(...)
 |      D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
 |  
 |  update(...)
 |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
 |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
 |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
 |      In either case, this is followed by: for k in F:  D[k] = F[k]
 |  
 |  values(...)
 |      D.values() -> an object providing a view on D's values
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from builtins.dict:
 |  
 |  __hash__ = None
",class,"('(self, init={})',)",scipy,1.1.0,scipy.io.idl.AttrDict,io.idl,AttrDict,"Python Library Documentation: class AttrDict in module scipy.io.idl

class AttrDict(builtins.dict)
 |  A case-insensitive dictionary with access via item, attribute, and call
 |  notations:
 |  
 |      >>> d = AttrDict()
 |      >>> d['Variable'] = 123
 |      >>> d['Variable']
 |      123
 |      >>> d.Variable
 |      123
 |      >>> d.variable
 |      123
 |      >>> d('VARIABLE')
 |      123
 |  
 |  Method resolution order:
 |      AttrDict
 |      builtins.dict
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __call__ = __getitem__(self, name)
 |  
 |  __getattr__ = __getitem__(self, name)
 |  
 |  __getitem__(self, name)
 |      x.__getitem__(y) <==> x[y]
 |  
 |  __init__(self, init={})
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __setattr__ = __setitem__(self, key, value)
 |  
 |  __setitem__(self, key, value)
 |      Set self[key] to value.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.dict:
 |  
 |  __contains__(self, key, /)
 |      True if D has a key k, else False.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __sizeof__(...)
 |      D.__sizeof__() -> size of D in memory, in bytes
 |  
 |  clear(...)
 |      D.clear() -> None.  Remove all items from D.
 |  
 |  copy(...)
 |      D.copy() -> a shallow copy of D
 |  
 |  fromkeys(iterable, value=None, /) from builtins.type
 |      Returns a new dict with keys from iterable and values equal to value.
 |  
 |  get(...)
 |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
 |  
 |  items(...)
 |      D.items() -> a set-like object providing a view on D's items
 |  
 |  keys(...)
 |      D.keys() -> a set-like object providing a view on D's keys
 |  
 |  pop(...)
 |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
 |      If key is not found, d is returned if given, otherwise KeyError is raised
 |  
 |  popitem(...)
 |      D.popitem() -> (k, v), remove and return some (key, value) pair as a
 |      2-tuple; but raise KeyError if D is empty.
 |  
 |  setdefault(...)
 |      D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
 |  
 |  update(...)
 |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
 |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
 |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
 |      In either case, this is followed by: for k in F:  D[k] = F[k]
 |  
 |  values(...)
 |      D.values() -> an object providing a view on D's values
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from builtins.dict:
 |  
 |  __hash__ = None
",class,"('self', 'init')","(nan, {})","(nan, 'dict')","('arg_info', 'arg_info')","('(self, init={})',)"
scipy,1.1.0,scipy.io.idl.ObjectPointer,io.idl,ObjectPointer,"Python Library Documentation: class ObjectPointer in module scipy.io.idl

class ObjectPointer(Pointer)
 |  Class used to define object pointers
 |  
 |  Method resolution order:
 |      ObjectPointer
 |      Pointer
 |      builtins.object
 |  
 |  Methods inherited from Pointer:
 |  
 |  __init__(self, index)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Pointer:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, index)',)",scipy,1.1.0,scipy.io.idl.ObjectPointer,io.idl,ObjectPointer,"Python Library Documentation: class ObjectPointer in module scipy.io.idl

class ObjectPointer(Pointer)
 |  Class used to define object pointers
 |  
 |  Method resolution order:
 |      ObjectPointer
 |      Pointer
 |      builtins.object
 |  
 |  Methods inherited from Pointer:
 |  
 |  __init__(self, index)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Pointer:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'index')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(self, index)',)"
scipy,1.1.0,scipy.io.idl.Pointer,io.idl,Pointer,"Python Library Documentation: class Pointer in module scipy.io.idl

class Pointer(builtins.object)
 |  Class used to define pointers
 |  
 |  Methods defined here:
 |  
 |  __init__(self, index)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, index)',)",scipy,1.1.0,scipy.io.idl.Pointer,io.idl,Pointer,"Python Library Documentation: class Pointer in module scipy.io.idl

class Pointer(builtins.object)
 |  Class used to define pointers
 |  
 |  Methods defined here:
 |  
 |  __init__(self, index)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'index')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(self, index)',)"
scipy,1.1.0,scipy.io.idl._align_32,io.idl,_align_32,"Python Library Documentation: function _align_32 in module scipy.io.idl

_align_32(f)
    Align to the next 32-bit position in a file
",function,"('(f)',)",scipy,1.1.0,scipy.io.idl._align_32,io.idl,_align_32,"Python Library Documentation: function _align_32 in module scipy.io.idl

_align_32(f)
    Align to the next 32-bit position in a file
",function,"('f',)","(nan,)","(nan,)","('arg_info',)","('(f)',)"
scipy,1.1.0,scipy.io.idl._read_array,io.idl,_read_array,"Python Library Documentation: function _read_array in module scipy.io.idl

_read_array(f, typecode, array_desc)
    Read an array of type `typecode`, with the array descriptor given as
    `array_desc`.
",function,"('(f, typecode, array_desc)',)",scipy,1.1.0,scipy.io.idl._read_array,io.idl,_read_array,"Python Library Documentation: function _read_array in module scipy.io.idl

_read_array(f, typecode, array_desc)
    Read an array of type `typecode`, with the array descriptor given as
    `array_desc`.
",function,"('f', 'typecode', 'array_desc')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(f, typecode, array_desc)',)"
scipy,1.1.0,scipy.io.idl._read_arraydesc,io.idl,_read_arraydesc,"Python Library Documentation: function _read_arraydesc in module scipy.io.idl

_read_arraydesc(f)
    Function to read in an array descriptor
",function,"('(f)',)",scipy,1.1.0,scipy.io.idl._read_arraydesc,io.idl,_read_arraydesc,"Python Library Documentation: function _read_arraydesc in module scipy.io.idl

_read_arraydesc(f)
    Function to read in an array descriptor
",function,"('f',)","(nan,)","(nan,)","('arg_info',)","('(f)',)"
scipy,1.1.0,scipy.io.idl._read_byte,io.idl,_read_byte,"Python Library Documentation: function _read_byte in module scipy.io.idl

_read_byte(f)
    Read a single byte
",function,"('(f)',)",scipy,1.1.0,scipy.io.idl._read_byte,io.idl,_read_byte,"Python Library Documentation: function _read_byte in module scipy.io.idl

_read_byte(f)
    Read a single byte
",function,"('f',)","(nan,)","(nan,)","('arg_info',)","('(f)',)"
scipy,1.1.0,scipy.io.idl._read_bytes,io.idl,_read_bytes,"Python Library Documentation: function _read_bytes in module scipy.io.idl

_read_bytes(f, n)
    Read the next `n` bytes
",function,"('(f, n)',)",scipy,1.1.0,scipy.io.idl._read_bytes,io.idl,_read_bytes,"Python Library Documentation: function _read_bytes in module scipy.io.idl

_read_bytes(f, n)
    Read the next `n` bytes
",function,"('f', 'n')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(f, n)',)"
scipy,1.1.0,scipy.io.idl._read_data,io.idl,_read_data,"Python Library Documentation: function _read_data in module scipy.io.idl

_read_data(f, dtype)
    Read a variable with a specified data type
",function,"('(f, dtype)',)",scipy,1.1.0,scipy.io.idl._read_data,io.idl,_read_data,"Python Library Documentation: function _read_data in module scipy.io.idl

_read_data(f, dtype)
    Read a variable with a specified data type
",function,"('f', 'dtype')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(f, dtype)',)"
scipy,1.1.0,scipy.io.idl._read_float32,io.idl,_read_float32,"Python Library Documentation: function _read_float32 in module scipy.io.idl

_read_float32(f)
    Read a 32-bit float
",function,"('(f)',)",scipy,1.1.0,scipy.io.idl._read_float32,io.idl,_read_float32,"Python Library Documentation: function _read_float32 in module scipy.io.idl

_read_float32(f)
    Read a 32-bit float
",function,"('f',)","(nan,)","(nan,)","('arg_info',)","('(f)',)"
scipy,1.1.0,scipy.io.idl._read_float64,io.idl,_read_float64,"Python Library Documentation: function _read_float64 in module scipy.io.idl

_read_float64(f)
    Read a 64-bit float
",function,"('(f)',)",scipy,1.1.0,scipy.io.idl._read_float64,io.idl,_read_float64,"Python Library Documentation: function _read_float64 in module scipy.io.idl

_read_float64(f)
    Read a 64-bit float
",function,"('f',)","(nan,)","(nan,)","('arg_info',)","('(f)',)"
scipy,1.1.0,scipy.io.idl._read_int16,io.idl,_read_int16,"Python Library Documentation: function _read_int16 in module scipy.io.idl

_read_int16(f)
    Read a signed 16-bit integer
",function,"('(f)',)",scipy,1.1.0,scipy.io.idl._read_int16,io.idl,_read_int16,"Python Library Documentation: function _read_int16 in module scipy.io.idl

_read_int16(f)
    Read a signed 16-bit integer
",function,"('f',)","(nan,)","(nan,)","('arg_info',)","('(f)',)"
scipy,1.1.0,scipy.io.idl._read_int32,io.idl,_read_int32,"Python Library Documentation: function _read_int32 in module scipy.io.idl

_read_int32(f)
    Read a signed 32-bit integer
",function,"('(f)',)",scipy,1.1.0,scipy.io.idl._read_int32,io.idl,_read_int32,"Python Library Documentation: function _read_int32 in module scipy.io.idl

_read_int32(f)
    Read a signed 32-bit integer
",function,"('f',)","(nan,)","(nan,)","('arg_info',)","('(f)',)"
scipy,1.1.0,scipy.io.idl._read_int64,io.idl,_read_int64,"Python Library Documentation: function _read_int64 in module scipy.io.idl

_read_int64(f)
    Read a signed 64-bit integer
",function,"('(f)',)",scipy,1.1.0,scipy.io.idl._read_int64,io.idl,_read_int64,"Python Library Documentation: function _read_int64 in module scipy.io.idl

_read_int64(f)
    Read a signed 64-bit integer
",function,"('f',)","(nan,)","(nan,)","('arg_info',)","('(f)',)"
scipy,1.1.0,scipy.io.idl._read_long,io.idl,_read_long,"Python Library Documentation: function _read_long in module scipy.io.idl

_read_long(f)
    Read a signed 32-bit integer
",function,"('(f)',)",scipy,1.1.0,scipy.io.idl._read_long,io.idl,_read_long,"Python Library Documentation: function _read_long in module scipy.io.idl

_read_long(f)
    Read a signed 32-bit integer
",function,"('f',)","(nan,)","(nan,)","('arg_info',)","('(f)',)"
scipy,1.1.0,scipy.io.idl._read_record,io.idl,_read_record,"Python Library Documentation: function _read_record in module scipy.io.idl

_read_record(f)
    Function to read in a full record
",function,"('(f)',)",scipy,1.1.0,scipy.io.idl._read_record,io.idl,_read_record,"Python Library Documentation: function _read_record in module scipy.io.idl

_read_record(f)
    Function to read in a full record
",function,"('f',)","(nan,)","(nan,)","('arg_info',)","('(f)',)"
scipy,1.1.0,scipy.io.idl._read_string,io.idl,_read_string,"Python Library Documentation: function _read_string in module scipy.io.idl

_read_string(f)
    Read a string
",function,"('(f)',)",scipy,1.1.0,scipy.io.idl._read_string,io.idl,_read_string,"Python Library Documentation: function _read_string in module scipy.io.idl

_read_string(f)
    Read a string
",function,"('f',)","(nan,)","(nan,)","('arg_info',)","('(f)',)"
scipy,1.1.0,scipy.io.idl._read_string_data,io.idl,_read_string_data,"Python Library Documentation: function _read_string_data in module scipy.io.idl

_read_string_data(f)
    Read a data string (length is specified twice)
",function,"('(f)',)",scipy,1.1.0,scipy.io.idl._read_string_data,io.idl,_read_string_data,"Python Library Documentation: function _read_string_data in module scipy.io.idl

_read_string_data(f)
    Read a data string (length is specified twice)
",function,"('f',)","(nan,)","(nan,)","('arg_info',)","('(f)',)"
scipy,1.1.0,scipy.io.idl._read_structdesc,io.idl,_read_structdesc,"Python Library Documentation: function _read_structdesc in module scipy.io.idl

_read_structdesc(f)
    Function to read in a structure descriptor
",function,"('(f)',)",scipy,1.1.0,scipy.io.idl._read_structdesc,io.idl,_read_structdesc,"Python Library Documentation: function _read_structdesc in module scipy.io.idl

_read_structdesc(f)
    Function to read in a structure descriptor
",function,"('f',)","(nan,)","(nan,)","('arg_info',)","('(f)',)"
scipy,1.1.0,scipy.io.idl._read_structure,io.idl,_read_structure,"Python Library Documentation: function _read_structure in module scipy.io.idl

_read_structure(f, array_desc, struct_desc)
    Read a structure, with the array and structure descriptors given as
    `array_desc` and `structure_desc` respectively.
",function,"('(f, array_desc, struct_desc)',)",scipy,1.1.0,scipy.io.idl._read_structure,io.idl,_read_structure,"Python Library Documentation: function _read_structure in module scipy.io.idl

_read_structure(f, array_desc, struct_desc)
    Read a structure, with the array and structure descriptors given as
    `array_desc` and `structure_desc` respectively.
",function,"('f', 'array_desc', 'struct_desc')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(f, array_desc, struct_desc)',)"
scipy,1.1.0,scipy.io.idl._read_tagdesc,io.idl,_read_tagdesc,"Python Library Documentation: function _read_tagdesc in module scipy.io.idl

_read_tagdesc(f)
    Function to read in a tag descriptor
",function,"('(f)',)",scipy,1.1.0,scipy.io.idl._read_tagdesc,io.idl,_read_tagdesc,"Python Library Documentation: function _read_tagdesc in module scipy.io.idl

_read_tagdesc(f)
    Function to read in a tag descriptor
",function,"('f',)","(nan,)","(nan,)","('arg_info',)","('(f)',)"
scipy,1.1.0,scipy.io.idl._read_typedesc,io.idl,_read_typedesc,"Python Library Documentation: function _read_typedesc in module scipy.io.idl

_read_typedesc(f)
    Function to read in a type descriptor
",function,"('(f)',)",scipy,1.1.0,scipy.io.idl._read_typedesc,io.idl,_read_typedesc,"Python Library Documentation: function _read_typedesc in module scipy.io.idl

_read_typedesc(f)
    Function to read in a type descriptor
",function,"('f',)","(nan,)","(nan,)","('arg_info',)","('(f)',)"
scipy,1.1.0,scipy.io.idl._read_uint16,io.idl,_read_uint16,"Python Library Documentation: function _read_uint16 in module scipy.io.idl

_read_uint16(f)
    Read an unsigned 16-bit integer
",function,"('(f)',)",scipy,1.1.0,scipy.io.idl._read_uint16,io.idl,_read_uint16,"Python Library Documentation: function _read_uint16 in module scipy.io.idl

_read_uint16(f)
    Read an unsigned 16-bit integer
",function,"('f',)","(nan,)","(nan,)","('arg_info',)","('(f)',)"
scipy,1.1.0,scipy.io.idl._read_uint32,io.idl,_read_uint32,"Python Library Documentation: function _read_uint32 in module scipy.io.idl

_read_uint32(f)
    Read an unsigned 32-bit integer
",function,"('(f)',)",scipy,1.1.0,scipy.io.idl._read_uint32,io.idl,_read_uint32,"Python Library Documentation: function _read_uint32 in module scipy.io.idl

_read_uint32(f)
    Read an unsigned 32-bit integer
",function,"('f',)","(nan,)","(nan,)","('arg_info',)","('(f)',)"
scipy,1.1.0,scipy.io.idl._read_uint64,io.idl,_read_uint64,"Python Library Documentation: function _read_uint64 in module scipy.io.idl

_read_uint64(f)
    Read an unsigned 64-bit integer
",function,"('(f)',)",scipy,1.1.0,scipy.io.idl._read_uint64,io.idl,_read_uint64,"Python Library Documentation: function _read_uint64 in module scipy.io.idl

_read_uint64(f)
    Read an unsigned 64-bit integer
",function,"('f',)","(nan,)","(nan,)","('arg_info',)","('(f)',)"
scipy,1.1.0,scipy.io.idl._replace_heap,io.idl,_replace_heap,"Python Library Documentation: function _replace_heap in module scipy.io.idl

_replace_heap(variable, heap)
",function,"('(variable, heap)',)",scipy,1.1.0,scipy.io.idl._replace_heap,io.idl,_replace_heap,"Python Library Documentation: function _replace_heap in module scipy.io.idl

_replace_heap(variable, heap)
",function,"('variable', 'heap')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(variable, heap)',)"
scipy,1.1.0,scipy.io.idl._skip_bytes,io.idl,_skip_bytes,"Python Library Documentation: function _skip_bytes in module scipy.io.idl

_skip_bytes(f, n)
    Skip `n` bytes
",function,"('(f, n)',)",scipy,1.1.0,scipy.io.idl._skip_bytes,io.idl,_skip_bytes,"Python Library Documentation: function _skip_bytes in module scipy.io.idl

_skip_bytes(f, n)
    Skip `n` bytes
",function,"('f', 'n')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(f, n)',)"
scipy,1.1.0,scipy.io.idl.asstr,io.idl,asstr,"Python Library Documentation: function asstr in module numpy.compat.py3k

asstr(s)
",function,"('(s)',)",scipy,1.1.0,scipy.io.idl.asstr,io.idl,asstr,"Python Library Documentation: function asstr in module numpy.compat.py3k

asstr(s)
",function,"('s',)","(nan,)","(nan,)","('arg_info',)","('(s)',)"
scipy,1.1.0,scipy.io.idl.readsav,io.idl,readsav,"Python Library Documentation: function readsav in module scipy.io.idl

readsav(file_name, idict=None, python_dict=False, uncompressed_file_name=None, verbose=False)
    Read an IDL .sav file.
    
    Parameters
    ----------
    file_name : str
        Name of the IDL save file.
    idict : dict, optional
        Dictionary in which to insert .sav file variables.
    python_dict : bool, optional
        By default, the object return is not a Python dictionary, but a
        case-insensitive dictionary with item, attribute, and call access
        to variables. To get a standard Python dictionary, set this option
        to True.
    uncompressed_file_name : str, optional
        This option only has an effect for .sav files written with the
        /compress option. If a file name is specified, compressed .sav
        files are uncompressed to this file. Otherwise, readsav will use
        the `tempfile` module to determine a temporary filename
        automatically, and will remove the temporary file upon successfully
        reading it in.
    verbose : bool, optional
        Whether to print out information about the save file, including
        the records read, and available variables.
    
    Returns
    -------
    idl_dict : AttrDict or dict
        If `python_dict` is set to False (default), this function returns a
        case-insensitive dictionary with item, attribute, and call access
        to variables. If `python_dict` is set to True, this function
        returns a Python dictionary with all variable names in lowercase.
        If `idict` was specified, then variables are written to the
        dictionary specified, and the updated dictionary is returned.
",function,"('(file_name, idict=None, python_dict=False, uncompressed_file_name=None, verbose=False)',)",scipy,1.1.0,scipy.io.idl.readsav,io.idl,readsav,"Python Library Documentation: function readsav in module scipy.io.idl

readsav(file_name, idict=None, python_dict=False, uncompressed_file_name=None, verbose=False)
    Read an IDL .sav file.
    
    Parameters
    ----------
    file_name : str
        Name of the IDL save file.
    idict : dict, optional
        Dictionary in which to insert .sav file variables.
    python_dict : bool, optional
        By default, the object return is not a Python dictionary, but a
        case-insensitive dictionary with item, attribute, and call access
        to variables. To get a standard Python dictionary, set this option
        to True.
    uncompressed_file_name : str, optional
        This option only has an effect for .sav files written with the
        /compress option. If a file name is specified, compressed .sav
        files are uncompressed to this file. Otherwise, readsav will use
        the `tempfile` module to determine a temporary filename
        automatically, and will remove the temporary file upon successfully
        reading it in.
    verbose : bool, optional
        Whether to print out information about the save file, including
        the records read, and available variables.
    
    Returns
    -------
    idl_dict : AttrDict or dict
        If `python_dict` is set to False (default), this function returns a
        case-insensitive dictionary with item, attribute, and call access
        to variables. If `python_dict` is set to True, this function
        returns a Python dictionary with all variable names in lowercase.
        If `idict` was specified, then variables are written to the
        dictionary specified, and the updated dictionary is returned.
",function,"('file_name', 'idict', 'python_dict', 'uncompressed_file_name', 'verbose')","(nan, None, False, None, False)","(nan, 'NoneType', 'bool', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(file_name, idict=None, python_dict=False, uncompressed_file_name=None, verbose=False)',)"
scipy,1.1.0,scipy.io.loadmat,io,loadmat,"Python Library Documentation: function loadmat in module scipy.io.matlab.mio

loadmat(file_name, mdict=None, appendmat=True, **kwargs)
    Load MATLAB file.
    
    Parameters
    ----------
    file_name : str
       Name of the mat file (do not need .mat extension if
       appendmat==True). Can also pass open file-like object.
    mdict : dict, optional
        Dictionary in which to insert matfile variables.
    appendmat : bool, optional
       True to append the .mat extension to the end of the given
       filename, if not already present.
    byte_order : str or None, optional
       None by default, implying byte order guessed from mat
       file. Otherwise can be one of ('native', '=', 'little', '<',
       'BIG', '>').
    mat_dtype : bool, optional
       If True, return arrays in same dtype as would be loaded into
       MATLAB (instead of the dtype with which they are saved).
    squeeze_me : bool, optional
       Whether to squeeze unit matrix dimensions or not.
    chars_as_strings : bool, optional
       Whether to convert char arrays to string arrays.
    matlab_compatible : bool, optional
       Returns matrices as would be loaded by MATLAB (implies
       squeeze_me=False, chars_as_strings=False, mat_dtype=True,
       struct_as_record=True).
    struct_as_record : bool, optional
       Whether to load MATLAB structs as numpy record arrays, or as
       old-style numpy arrays with dtype=object.  Setting this flag to
       False replicates the behavior of scipy version 0.7.x (returning
       numpy object arrays).  The default setting is True, because it
       allows easier round-trip load and save of MATLAB files.
    verify_compressed_data_integrity : bool, optional
        Whether the length of compressed sequences in the MATLAB file
        should be checked, to ensure that they are not longer than we expect.
        It is advisable to enable this (the default) because overlong
        compressed sequences in MATLAB files generally indicate that the
        files have experienced some sort of corruption.
    variable_names : None or sequence
        If None (the default) - read all variables in file. Otherwise
        `variable_names` should be a sequence of strings, giving names of the
        matlab variables to read from the file.  The reader will skip any
        variable with a name not in this sequence, possibly saving some read
        processing.
    
    Returns
    -------
    mat_dict : dict
       dictionary with variable names as keys, and loaded matrices as
       values.
    
    Notes
    -----
    v4 (Level 1.0), v6 and v7 to 7.2 matfiles are supported.
    
    You will need an HDF5 python library to read matlab 7.3 format mat
    files.  Because scipy does not supply one, we do not implement the
    HDF5 / 7.3 interface here.
",function,"('(file_name, mdict=None, appendmat=True, **kwargs)',)",scipy,1.1.0,scipy.io.loadmat,io,loadmat,"Python Library Documentation: function loadmat in module scipy.io.matlab.mio

loadmat(file_name, mdict=None, appendmat=True, **kwargs)
    Load MATLAB file.
    
    Parameters
    ----------
    file_name : str
       Name of the mat file (do not need .mat extension if
       appendmat==True). Can also pass open file-like object.
    mdict : dict, optional
        Dictionary in which to insert matfile variables.
    appendmat : bool, optional
       True to append the .mat extension to the end of the given
       filename, if not already present.
    byte_order : str or None, optional
       None by default, implying byte order guessed from mat
       file. Otherwise can be one of ('native', '=', 'little', '<',
       'BIG', '>').
    mat_dtype : bool, optional
       If True, return arrays in same dtype as would be loaded into
       MATLAB (instead of the dtype with which they are saved).
    squeeze_me : bool, optional
       Whether to squeeze unit matrix dimensions or not.
    chars_as_strings : bool, optional
       Whether to convert char arrays to string arrays.
    matlab_compatible : bool, optional
       Returns matrices as would be loaded by MATLAB (implies
       squeeze_me=False, chars_as_strings=False, mat_dtype=True,
       struct_as_record=True).
    struct_as_record : bool, optional
       Whether to load MATLAB structs as numpy record arrays, or as
       old-style numpy arrays with dtype=object.  Setting this flag to
       False replicates the behavior of scipy version 0.7.x (returning
       numpy object arrays).  The default setting is True, because it
       allows easier round-trip load and save of MATLAB files.
    verify_compressed_data_integrity : bool, optional
        Whether the length of compressed sequences in the MATLAB file
        should be checked, to ensure that they are not longer than we expect.
        It is advisable to enable this (the default) because overlong
        compressed sequences in MATLAB files generally indicate that the
        files have experienced some sort of corruption.
    variable_names : None or sequence
        If None (the default) - read all variables in file. Otherwise
        `variable_names` should be a sequence of strings, giving names of the
        matlab variables to read from the file.  The reader will skip any
        variable with a name not in this sequence, possibly saving some read
        processing.
    
    Returns
    -------
    mat_dict : dict
       dictionary with variable names as keys, and loaded matrices as
       values.
    
    Notes
    -----
    v4 (Level 1.0), v6 and v7 to 7.2 matfiles are supported.
    
    You will need an HDF5 python library to read matlab 7.3 format mat
    files.  Because scipy does not supply one, we do not implement the
    HDF5 / 7.3 interface here.
",function,"('file_name', 'mdict', 'appendmat')","(nan, None, True)","(nan, 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info')","('(file_name, mdict=None, appendmat=True, **kwargs)',)"
scipy,1.1.0,scipy.io.matlab.byteordercodes.to_numpy_code,io.matlab.byteordercodes,to_numpy_code,"Python Library Documentation: function to_numpy_code in module scipy.io.matlab.byteordercodes

to_numpy_code(code)
    Convert various order codings to numpy format.
    
    Parameters
    ----------
    code : str
        The code to convert. It is converted to lower case before parsing.
        Legal values are:
        'little', 'big', 'l', 'b', 'le', 'be', '<', '>', 'native', '=',
        'swapped', 's'.
    
    Returns
    -------
    out_code : {'<', '>'}
        Here '<' is the numpy dtype code for little endian,
        and '>' is the code for big endian.
    
    Examples
    --------
    >>> import sys
    >>> sys_is_le == (sys.byteorder == 'little')
    True
    >>> to_numpy_code('big')
    '>'
    >>> to_numpy_code('little')
    '<'
    >>> nc = to_numpy_code('native')
    >>> nc == '<' if sys_is_le else nc == '>'
    True
    >>> sc = to_numpy_code('swapped')
    >>> sc == '>' if sys_is_le else sc == '<'
    True
",function,"('(code)',)",scipy,1.1.0,scipy.io.matlab.byteordercodes.to_numpy_code,io.matlab.byteordercodes,to_numpy_code,"Python Library Documentation: function to_numpy_code in module scipy.io.matlab.byteordercodes

to_numpy_code(code)
    Convert various order codings to numpy format.
    
    Parameters
    ----------
    code : str
        The code to convert. It is converted to lower case before parsing.
        Legal values are:
        'little', 'big', 'l', 'b', 'le', 'be', '<', '>', 'native', '=',
        'swapped', 's'.
    
    Returns
    -------
    out_code : {'<', '>'}
        Here '<' is the numpy dtype code for little endian,
        and '>' is the code for big endian.
    
    Examples
    --------
    >>> import sys
    >>> sys_is_le == (sys.byteorder == 'little')
    True
    >>> to_numpy_code('big')
    '>'
    >>> to_numpy_code('little')
    '<'
    >>> nc = to_numpy_code('native')
    >>> nc == '<' if sys_is_le else nc == '>'
    True
    >>> sc = to_numpy_code('swapped')
    >>> sc == '>' if sys_is_le else sc == '<'
    True
",function,"('code',)","(nan,)","(nan,)","('arg_info',)","('(code)',)"
scipy,1.1.0,scipy.io.matlab.loadmat,io.matlab,loadmat,"Python Library Documentation: function loadmat in module scipy.io.matlab.mio

loadmat(file_name, mdict=None, appendmat=True, **kwargs)
    Load MATLAB file.
    
    Parameters
    ----------
    file_name : str
       Name of the mat file (do not need .mat extension if
       appendmat==True). Can also pass open file-like object.
    mdict : dict, optional
        Dictionary in which to insert matfile variables.
    appendmat : bool, optional
       True to append the .mat extension to the end of the given
       filename, if not already present.
    byte_order : str or None, optional
       None by default, implying byte order guessed from mat
       file. Otherwise can be one of ('native', '=', 'little', '<',
       'BIG', '>').
    mat_dtype : bool, optional
       If True, return arrays in same dtype as would be loaded into
       MATLAB (instead of the dtype with which they are saved).
    squeeze_me : bool, optional
       Whether to squeeze unit matrix dimensions or not.
    chars_as_strings : bool, optional
       Whether to convert char arrays to string arrays.
    matlab_compatible : bool, optional
       Returns matrices as would be loaded by MATLAB (implies
       squeeze_me=False, chars_as_strings=False, mat_dtype=True,
       struct_as_record=True).
    struct_as_record : bool, optional
       Whether to load MATLAB structs as numpy record arrays, or as
       old-style numpy arrays with dtype=object.  Setting this flag to
       False replicates the behavior of scipy version 0.7.x (returning
       numpy object arrays).  The default setting is True, because it
       allows easier round-trip load and save of MATLAB files.
    verify_compressed_data_integrity : bool, optional
        Whether the length of compressed sequences in the MATLAB file
        should be checked, to ensure that they are not longer than we expect.
        It is advisable to enable this (the default) because overlong
        compressed sequences in MATLAB files generally indicate that the
        files have experienced some sort of corruption.
    variable_names : None or sequence
        If None (the default) - read all variables in file. Otherwise
        `variable_names` should be a sequence of strings, giving names of the
        matlab variables to read from the file.  The reader will skip any
        variable with a name not in this sequence, possibly saving some read
        processing.
    
    Returns
    -------
    mat_dict : dict
       dictionary with variable names as keys, and loaded matrices as
       values.
    
    Notes
    -----
    v4 (Level 1.0), v6 and v7 to 7.2 matfiles are supported.
    
    You will need an HDF5 python library to read matlab 7.3 format mat
    files.  Because scipy does not supply one, we do not implement the
    HDF5 / 7.3 interface here.
",function,"('(file_name, mdict=None, appendmat=True, **kwargs)',)",scipy,1.1.0,scipy.io.matlab.loadmat,io.matlab,loadmat,"Python Library Documentation: function loadmat in module scipy.io.matlab.mio

loadmat(file_name, mdict=None, appendmat=True, **kwargs)
    Load MATLAB file.
    
    Parameters
    ----------
    file_name : str
       Name of the mat file (do not need .mat extension if
       appendmat==True). Can also pass open file-like object.
    mdict : dict, optional
        Dictionary in which to insert matfile variables.
    appendmat : bool, optional
       True to append the .mat extension to the end of the given
       filename, if not already present.
    byte_order : str or None, optional
       None by default, implying byte order guessed from mat
       file. Otherwise can be one of ('native', '=', 'little', '<',
       'BIG', '>').
    mat_dtype : bool, optional
       If True, return arrays in same dtype as would be loaded into
       MATLAB (instead of the dtype with which they are saved).
    squeeze_me : bool, optional
       Whether to squeeze unit matrix dimensions or not.
    chars_as_strings : bool, optional
       Whether to convert char arrays to string arrays.
    matlab_compatible : bool, optional
       Returns matrices as would be loaded by MATLAB (implies
       squeeze_me=False, chars_as_strings=False, mat_dtype=True,
       struct_as_record=True).
    struct_as_record : bool, optional
       Whether to load MATLAB structs as numpy record arrays, or as
       old-style numpy arrays with dtype=object.  Setting this flag to
       False replicates the behavior of scipy version 0.7.x (returning
       numpy object arrays).  The default setting is True, because it
       allows easier round-trip load and save of MATLAB files.
    verify_compressed_data_integrity : bool, optional
        Whether the length of compressed sequences in the MATLAB file
        should be checked, to ensure that they are not longer than we expect.
        It is advisable to enable this (the default) because overlong
        compressed sequences in MATLAB files generally indicate that the
        files have experienced some sort of corruption.
    variable_names : None or sequence
        If None (the default) - read all variables in file. Otherwise
        `variable_names` should be a sequence of strings, giving names of the
        matlab variables to read from the file.  The reader will skip any
        variable with a name not in this sequence, possibly saving some read
        processing.
    
    Returns
    -------
    mat_dict : dict
       dictionary with variable names as keys, and loaded matrices as
       values.
    
    Notes
    -----
    v4 (Level 1.0), v6 and v7 to 7.2 matfiles are supported.
    
    You will need an HDF5 python library to read matlab 7.3 format mat
    files.  Because scipy does not supply one, we do not implement the
    HDF5 / 7.3 interface here.
",function,"('file_name', 'mdict', 'appendmat')","(nan, None, True)","(nan, 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info')","('(file_name, mdict=None, appendmat=True, **kwargs)',)"
scipy,1.1.0,scipy.io.matlab.mio.MatFile4Reader,io.matlab.mio,MatFile4Reader,"Python Library Documentation: class MatFile4Reader in module scipy.io.matlab.mio4

class MatFile4Reader(scipy.io.matlab.miobase.MatFileReader)
 |  Reader for Mat4 files
 |  
 |  Method resolution order:
 |      MatFile4Reader
 |      scipy.io.matlab.miobase.MatFileReader
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, mat_stream, *args, **kwargs)
 |      Initialize matlab 4 file reader
 |      
 |      mat_stream : file-like
 |         Object with file API, open for reading.
 |      byte_order : str or None, optional
 |         None by default, implying byte order guessed from mat
 |         file. Otherwise can be one of ('native', '=', 'little', '<',
 |         'BIG', '>').
 |      mat_dtype : bool, optional
 |         If True, return arrays in same dtype as would be loaded into
 |         MATLAB (instead of the dtype with which they are saved).
 |      squeeze_me : bool, optional
 |         Whether to squeeze unit matrix dimensions or not.
 |      chars_as_strings : bool, optional
 |         Whether to convert char arrays to string arrays.
 |      matlab_compatible : bool, optional
 |         Returns matrices as would be loaded by MATLAB (implies
 |         squeeze_me=False, chars_as_strings=False, mat_dtype=True,
 |         struct_as_record=True).
 |  
 |  get_variables(self, variable_names=None)
 |      get variables from stream as dictionary
 |      
 |      Parameters
 |      ----------
 |      variable_names : None or str or sequence of str, optional
 |          variable name, or sequence of variable names to get from Mat file /
 |          file stream.  If None, then get all variables in file
 |  
 |  guess_byte_order(self)
 |      As we do not know what file type we have, assume native
 |  
 |  initialize_read(self)
 |      Run when beginning read of variables
 |      
 |      Sets up readers from parameters in `self`
 |  
 |  list_variables(self)
 |      list variables from stream
 |  
 |  read_var_array(self, header, process=True)
 |      Read array, given `header`
 |      
 |      Parameters
 |      ----------
 |      header : header object
 |         object with fields defining variable header
 |      process : {True, False}, optional
 |         If True, apply recursive post-processing during loading of array.
 |      
 |      Returns
 |      -------
 |      arr : array
 |         array with post-processing applied or not according to
 |         `process`.
 |  
 |  read_var_header(self)
 |      Read and return header, next position
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      header : object
 |         object that can be passed to self.read_var_array, and that
 |         has attributes ``name`` and ``is_global``
 |      next_position : int
 |         position in stream of next variable
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.io.matlab.miobase.MatFileReader:
 |  
 |  end_of_stream(self)
 |  
 |  set_matlab_compatible(self)
 |      Sets options to return arrays as MATLAB loads them
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.io.matlab.miobase.MatFileReader:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, mat_stream, *args, **kwargs)',)",scipy,1.1.0,scipy.io.matlab.mio.MatFile4Reader,io.matlab.mio,MatFile4Reader,"Python Library Documentation: class MatFile4Reader in module scipy.io.matlab.mio4

class MatFile4Reader(scipy.io.matlab.miobase.MatFileReader)
 |  Reader for Mat4 files
 |  
 |  Method resolution order:
 |      MatFile4Reader
 |      scipy.io.matlab.miobase.MatFileReader
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, mat_stream, *args, **kwargs)
 |      Initialize matlab 4 file reader
 |      
 |      mat_stream : file-like
 |         Object with file API, open for reading.
 |      byte_order : str or None, optional
 |         None by default, implying byte order guessed from mat
 |         file. Otherwise can be one of ('native', '=', 'little', '<',
 |         'BIG', '>').
 |      mat_dtype : bool, optional
 |         If True, return arrays in same dtype as would be loaded into
 |         MATLAB (instead of the dtype with which they are saved).
 |      squeeze_me : bool, optional
 |         Whether to squeeze unit matrix dimensions or not.
 |      chars_as_strings : bool, optional
 |         Whether to convert char arrays to string arrays.
 |      matlab_compatible : bool, optional
 |         Returns matrices as would be loaded by MATLAB (implies
 |         squeeze_me=False, chars_as_strings=False, mat_dtype=True,
 |         struct_as_record=True).
 |  
 |  get_variables(self, variable_names=None)
 |      get variables from stream as dictionary
 |      
 |      Parameters
 |      ----------
 |      variable_names : None or str or sequence of str, optional
 |          variable name, or sequence of variable names to get from Mat file /
 |          file stream.  If None, then get all variables in file
 |  
 |  guess_byte_order(self)
 |      As we do not know what file type we have, assume native
 |  
 |  initialize_read(self)
 |      Run when beginning read of variables
 |      
 |      Sets up readers from parameters in `self`
 |  
 |  list_variables(self)
 |      list variables from stream
 |  
 |  read_var_array(self, header, process=True)
 |      Read array, given `header`
 |      
 |      Parameters
 |      ----------
 |      header : header object
 |         object with fields defining variable header
 |      process : {True, False}, optional
 |         If True, apply recursive post-processing during loading of array.
 |      
 |      Returns
 |      -------
 |      arr : array
 |         array with post-processing applied or not according to
 |         `process`.
 |  
 |  read_var_header(self)
 |      Read and return header, next position
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      header : object
 |         object that can be passed to self.read_var_array, and that
 |         has attributes ``name`` and ``is_global``
 |      next_position : int
 |         position in stream of next variable
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.io.matlab.miobase.MatFileReader:
 |  
 |  end_of_stream(self)
 |  
 |  set_matlab_compatible(self)
 |      Sets options to return arrays as MATLAB loads them
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.io.matlab.miobase.MatFileReader:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'mat_stream')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(self, mat_stream, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.matlab.mio.MatFile4Writer,io.matlab.mio,MatFile4Writer,"Python Library Documentation: class MatFile4Writer in module scipy.io.matlab.mio4

class MatFile4Writer(builtins.object)
 |  Class for writing matlab 4 format files
 |  
 |  Methods defined here:
 |  
 |  __init__(self, file_stream, oned_as=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  put_variables(self, mdict, write_header=None)
 |      Write variables in `mdict` to stream
 |      
 |      Parameters
 |      ----------
 |      mdict : mapping
 |         mapping with method ``items`` return name, contents pairs
 |         where ``name`` which will appeak in the matlab workspace in
 |         file load, and ``contents`` is something writeable to a
 |         matlab file, such as a numpy array.
 |      write_header : {None, True, False}
 |         If True, then write the matlab file header before writing the
 |         variables.  If None (the default) then write the file header
 |         if we are at position 0 in the stream.  By setting False
 |         here, and setting the stream position to the end of the file,
 |         you can append variables to a matlab file
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, file_stream, oned_as=None)',)",scipy,1.1.0,scipy.io.matlab.mio.MatFile4Writer,io.matlab.mio,MatFile4Writer,"Python Library Documentation: class MatFile4Writer in module scipy.io.matlab.mio4

class MatFile4Writer(builtins.object)
 |  Class for writing matlab 4 format files
 |  
 |  Methods defined here:
 |  
 |  __init__(self, file_stream, oned_as=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  put_variables(self, mdict, write_header=None)
 |      Write variables in `mdict` to stream
 |      
 |      Parameters
 |      ----------
 |      mdict : mapping
 |         mapping with method ``items`` return name, contents pairs
 |         where ``name`` which will appeak in the matlab workspace in
 |         file load, and ``contents`` is something writeable to a
 |         matlab file, such as a numpy array.
 |      write_header : {None, True, False}
 |         If True, then write the matlab file header before writing the
 |         variables.  If None (the default) then write the file header
 |         if we are at position 0 in the stream.  By setting False
 |         here, and setting the stream position to the end of the file,
 |         you can append variables to a matlab file
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'file_stream', 'oned_as')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(self, file_stream, oned_as=None)',)"
scipy,1.1.0,scipy.io.matlab.mio.MatFile5Reader,io.matlab.mio,MatFile5Reader,"Python Library Documentation: class MatFile5Reader in module scipy.io.matlab.mio5

class MatFile5Reader(scipy.io.matlab.miobase.MatFileReader)
 |  Reader for Mat 5 mat files
 |  Adds the following attribute to base class
 |  
 |  uint16_codec - char codec to use for uint16 char arrays
 |      (defaults to system default codec)
 |  
 |  Uses variable reader that has the following stardard interface (see
 |  abstract class in ``miobase``::
 |  
 |     __init__(self, file_reader)
 |     read_header(self)
 |     array_from_header(self)
 |  
 |  and added interface::
 |  
 |     set_stream(self, stream)
 |     read_full_tag(self)
 |  
 |  Method resolution order:
 |      MatFile5Reader
 |      scipy.io.matlab.miobase.MatFileReader
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, mat_stream, byte_order=None, mat_dtype=False, squeeze_me=False, chars_as_strings=True, matlab_compatible=False, struct_as_record=True, verify_compressed_data_integrity=True, uint16_codec=None)
 |      Initializer for matlab 5 file format reader
 |      
 |      mat_stream : file-like
 |         Object with file API, open for reading.
 |      byte_order : str or None, optional
 |         None by default, implying byte order guessed from mat
 |         file. Otherwise can be one of ('native', '=', 'little', '<',
 |         'BIG', '>').
 |      mat_dtype : bool, optional
 |         If True, return arrays in same dtype as would be loaded into
 |         MATLAB (instead of the dtype with which they are saved).
 |      squeeze_me : bool, optional
 |         Whether to squeeze unit matrix dimensions or not.
 |      chars_as_strings : bool, optional
 |         Whether to convert char arrays to string arrays.
 |      matlab_compatible : bool, optional
 |         Returns matrices as would be loaded by MATLAB (implies
 |         squeeze_me=False, chars_as_strings=False, mat_dtype=True,
 |         struct_as_record=True).
 |      struct_as_record : bool, optional
 |         Whether to load MATLAB structs as numpy record arrays, or as
 |         old-style numpy arrays with dtype=object.  Setting this flag to
 |         False replicates the behavior of scipy version 0.7.x (returning
 |         numpy object arrays).  The default setting is True, because it
 |         allows easier round-trip load and save of MATLAB files.
 |      uint16_codec : {None, string}
 |          Set codec to use for uint16 char arrays (e.g. 'utf-8').
 |          Use system default codec if None
 |  
 |  get_variables(self, variable_names=None)
 |      get variables from stream as dictionary
 |      
 |      variable_names   - optional list of variable names to get
 |      
 |      If variable_names is None, then get all variables in file
 |  
 |  guess_byte_order(self)
 |      Guess byte order.
 |      Sets stream pointer to 0
 |  
 |  initialize_read(self)
 |      Run when beginning read of variables
 |      
 |      Sets up readers from parameters in `self`
 |  
 |  list_variables(self)
 |      list variables from stream
 |  
 |  read_file_header(self)
 |      Read in mat 5 file header
 |  
 |  read_var_array(self, header, process=True)
 |      Read array, given `header`
 |      
 |      Parameters
 |      ----------
 |      header : header object
 |         object with fields defining variable header
 |      process : {True, False} bool, optional
 |         If True, apply recursive post-processing during loading of
 |         array.
 |      
 |      Returns
 |      -------
 |      arr : array
 |         array with post-processing applied or not according to
 |         `process`.
 |  
 |  read_var_header(self)
 |      Read header, return header, next position
 |      
 |      Header has to define at least .name and .is_global
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      header : object
 |         object that can be passed to self.read_var_array, and that
 |         has attributes .name and .is_global
 |      next_position : int
 |         position in stream of next variable
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.io.matlab.miobase.MatFileReader:
 |  
 |  end_of_stream(self)
 |  
 |  set_matlab_compatible(self)
 |      Sets options to return arrays as MATLAB loads them
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.io.matlab.miobase.MatFileReader:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, mat_stream, byte_order=None, mat_dtype=False, squeeze_me=False, chars_as_strings=True, matlab_compatible=False, struct_as_record=True, verify_compressed_data_integrity=True, uint16_codec=None)',)",scipy,1.1.0,scipy.io.matlab.mio.MatFile5Reader,io.matlab.mio,MatFile5Reader,"Python Library Documentation: class MatFile5Reader in module scipy.io.matlab.mio5

class MatFile5Reader(scipy.io.matlab.miobase.MatFileReader)
 |  Reader for Mat 5 mat files
 |  Adds the following attribute to base class
 |  
 |  uint16_codec - char codec to use for uint16 char arrays
 |      (defaults to system default codec)
 |  
 |  Uses variable reader that has the following stardard interface (see
 |  abstract class in ``miobase``::
 |  
 |     __init__(self, file_reader)
 |     read_header(self)
 |     array_from_header(self)
 |  
 |  and added interface::
 |  
 |     set_stream(self, stream)
 |     read_full_tag(self)
 |  
 |  Method resolution order:
 |      MatFile5Reader
 |      scipy.io.matlab.miobase.MatFileReader
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, mat_stream, byte_order=None, mat_dtype=False, squeeze_me=False, chars_as_strings=True, matlab_compatible=False, struct_as_record=True, verify_compressed_data_integrity=True, uint16_codec=None)
 |      Initializer for matlab 5 file format reader
 |      
 |      mat_stream : file-like
 |         Object with file API, open for reading.
 |      byte_order : str or None, optional
 |         None by default, implying byte order guessed from mat
 |         file. Otherwise can be one of ('native', '=', 'little', '<',
 |         'BIG', '>').
 |      mat_dtype : bool, optional
 |         If True, return arrays in same dtype as would be loaded into
 |         MATLAB (instead of the dtype with which they are saved).
 |      squeeze_me : bool, optional
 |         Whether to squeeze unit matrix dimensions or not.
 |      chars_as_strings : bool, optional
 |         Whether to convert char arrays to string arrays.
 |      matlab_compatible : bool, optional
 |         Returns matrices as would be loaded by MATLAB (implies
 |         squeeze_me=False, chars_as_strings=False, mat_dtype=True,
 |         struct_as_record=True).
 |      struct_as_record : bool, optional
 |         Whether to load MATLAB structs as numpy record arrays, or as
 |         old-style numpy arrays with dtype=object.  Setting this flag to
 |         False replicates the behavior of scipy version 0.7.x (returning
 |         numpy object arrays).  The default setting is True, because it
 |         allows easier round-trip load and save of MATLAB files.
 |      uint16_codec : {None, string}
 |          Set codec to use for uint16 char arrays (e.g. 'utf-8').
 |          Use system default codec if None
 |  
 |  get_variables(self, variable_names=None)
 |      get variables from stream as dictionary
 |      
 |      variable_names   - optional list of variable names to get
 |      
 |      If variable_names is None, then get all variables in file
 |  
 |  guess_byte_order(self)
 |      Guess byte order.
 |      Sets stream pointer to 0
 |  
 |  initialize_read(self)
 |      Run when beginning read of variables
 |      
 |      Sets up readers from parameters in `self`
 |  
 |  list_variables(self)
 |      list variables from stream
 |  
 |  read_file_header(self)
 |      Read in mat 5 file header
 |  
 |  read_var_array(self, header, process=True)
 |      Read array, given `header`
 |      
 |      Parameters
 |      ----------
 |      header : header object
 |         object with fields defining variable header
 |      process : {True, False} bool, optional
 |         If True, apply recursive post-processing during loading of
 |         array.
 |      
 |      Returns
 |      -------
 |      arr : array
 |         array with post-processing applied or not according to
 |         `process`.
 |  
 |  read_var_header(self)
 |      Read header, return header, next position
 |      
 |      Header has to define at least .name and .is_global
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      header : object
 |         object that can be passed to self.read_var_array, and that
 |         has attributes .name and .is_global
 |      next_position : int
 |         position in stream of next variable
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.io.matlab.miobase.MatFileReader:
 |  
 |  end_of_stream(self)
 |  
 |  set_matlab_compatible(self)
 |      Sets options to return arrays as MATLAB loads them
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.io.matlab.miobase.MatFileReader:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'mat_stream', 'byte_order', 'mat_dtype', 'squeeze_me', 'chars_as_strings', 'matlab_compatible', 'struct_as_record', 'verify_compressed_data_integrity', 'uint16_codec')","(nan, nan, None, False, False, True, False, True, True, None)","(nan, nan, 'NoneType', 'bool', 'bool', 'bool', 'bool', 'bool', 'bool', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, mat_stream, byte_order=None, mat_dtype=False, squeeze_me=False, chars_as_strings=True, matlab_compatible=False, struct_as_record=True, verify_compressed_data_integrity=True, uint16_codec=None)',)"
scipy,1.1.0,scipy.io.matlab.mio.MatFile5Writer,io.matlab.mio,MatFile5Writer,"Python Library Documentation: class MatFile5Writer in module scipy.io.matlab.mio5

class MatFile5Writer(builtins.object)
 |  Class for writing mat5 files
 |  
 |  Methods defined here:
 |  
 |  __init__(self, file_stream, do_compression=False, unicode_strings=False, global_vars=None, long_field_names=False, oned_as='row')
 |      Initialize writer for matlab 5 format files
 |      
 |      Parameters
 |      ----------
 |      do_compression : bool, optional
 |         Whether to compress matrices on write. Default is False.
 |      unicode_strings : bool, optional
 |         If True, write strings as Unicode, else MATLAB usual encoding.
 |      global_vars : None or sequence of strings, optional
 |          Names of variables to be marked as global for matlab
 |      long_field_names : bool, optional
 |         * False - maximum field name length in a structure is 31 characters
 |           which is the documented maximum length. This is the default.
 |         * True - maximum field name length in a structure is 63 characters
 |           which works for MATLAB 7.6
 |      oned_as : {'row', 'column'}, optional
 |         If 'column', write 1-D numpy arrays as column vectors.
 |         If 'row', write 1D numpy arrays as row vectors.
 |  
 |  put_variables(self, mdict, write_header=None)
 |      Write variables in `mdict` to stream
 |      
 |      Parameters
 |      ----------
 |      mdict : mapping
 |         mapping with method ``items`` returns name, contents pairs where
 |         ``name`` which will appear in the matlab workspace in file load, and
 |         ``contents`` is something writeable to a matlab file, such as a numpy
 |         array.
 |      write_header : {None, True, False}, optional
 |         If True, then write the matlab file header before writing the
 |         variables.  If None (the default) then write the file header
 |         if we are at position 0 in the stream.  By setting False
 |         here, and setting the stream position to the end of the file,
 |         you can append variables to a matlab file
 |  
 |  write_file_header(self)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"(""(self, file_stream, do_compression=False, unicode_strings=False, global_vars=None, long_field_names=False, oned_as='row')"",)",scipy,1.1.0,scipy.io.matlab.mio.MatFile5Writer,io.matlab.mio,MatFile5Writer,"Python Library Documentation: class MatFile5Writer in module scipy.io.matlab.mio5

class MatFile5Writer(builtins.object)
 |  Class for writing mat5 files
 |  
 |  Methods defined here:
 |  
 |  __init__(self, file_stream, do_compression=False, unicode_strings=False, global_vars=None, long_field_names=False, oned_as='row')
 |      Initialize writer for matlab 5 format files
 |      
 |      Parameters
 |      ----------
 |      do_compression : bool, optional
 |         Whether to compress matrices on write. Default is False.
 |      unicode_strings : bool, optional
 |         If True, write strings as Unicode, else MATLAB usual encoding.
 |      global_vars : None or sequence of strings, optional
 |          Names of variables to be marked as global for matlab
 |      long_field_names : bool, optional
 |         * False - maximum field name length in a structure is 31 characters
 |           which is the documented maximum length. This is the default.
 |         * True - maximum field name length in a structure is 63 characters
 |           which works for MATLAB 7.6
 |      oned_as : {'row', 'column'}, optional
 |         If 'column', write 1-D numpy arrays as column vectors.
 |         If 'row', write 1D numpy arrays as row vectors.
 |  
 |  put_variables(self, mdict, write_header=None)
 |      Write variables in `mdict` to stream
 |      
 |      Parameters
 |      ----------
 |      mdict : mapping
 |         mapping with method ``items`` returns name, contents pairs where
 |         ``name`` which will appear in the matlab workspace in file load, and
 |         ``contents`` is something writeable to a matlab file, such as a numpy
 |         array.
 |      write_header : {None, True, False}, optional
 |         If True, then write the matlab file header before writing the
 |         variables.  If None (the default) then write the file header
 |         if we are at position 0 in the stream.  By setting False
 |         here, and setting the stream position to the end of the file,
 |         you can append variables to a matlab file
 |  
 |  write_file_header(self)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'file_stream', 'do_compression', 'unicode_strings', 'global_vars', 'long_field_names', 'oned_as')","(nan, nan, False, False, None, False, 'row')","(nan, nan, 'bool', 'bool', 'NoneType', 'bool', 'str')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(self, file_stream, do_compression=False, unicode_strings=False, global_vars=None, long_field_names=False, oned_as='row')"",)"
scipy,1.1.0,scipy.io.matlab.mio._open_file,io.matlab.mio,_open_file,"Python Library Documentation: function _open_file in module scipy.io.matlab.mio

_open_file(file_like, appendmat)
    Open `file_like` and return as file-like object. First, check if object is
    already file-like; if so, return it as-is. Otherwise, try to pass it
    to open(). If that fails, and `file_like` is a string, and `appendmat` is true,
    append '.mat' and try again.
",function,"('(file_like, appendmat)',)",scipy,1.1.0,scipy.io.matlab.mio._open_file,io.matlab.mio,_open_file,"Python Library Documentation: function _open_file in module scipy.io.matlab.mio

_open_file(file_like, appendmat)
    Open `file_like` and return as file-like object. First, check if object is
    already file-like; if so, return it as-is. Otherwise, try to pass it
    to open(). If that fails, and `file_like` is a string, and `appendmat` is true,
    append '.mat' and try again.
",function,"('file_like', 'appendmat')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(file_like, appendmat)',)"
scipy,1.1.0,scipy.io.matlab.mio.docfiller,io.matlab.mio,decorate,"Python Library Documentation: function decorate in module scipy.misc.doccer

decorate(f)
",function,"('(f)',)",scipy,1.1.0,scipy.io.matlab.mio.docfiller,io.matlab.mio,decorate,"Python Library Documentation: function decorate in module scipy.misc.doccer

decorate(f)
",function,"('f',)","(nan,)","(nan,)","('arg_info',)","('(f)',)"
scipy,1.1.0,scipy.io.matlab.mio.get_matfile_version,io.matlab.mio,get_matfile_version,"Python Library Documentation: function get_matfile_version in module scipy.io.matlab.miobase

get_matfile_version(fileobj)
    Return major, minor tuple depending on apparent mat file type
    
    Where:
    
     #. 0,x -> version 4 format mat files
     #. 1,x -> version 5 format mat files
     #. 2,x -> version 7.3 format mat files (HDF format)
    
    Parameters
    ----------
    fileobj : file_like
        object implementing seek() and read()
    
    Returns
    -------
    major_version : {0, 1, 2}
        major MATLAB File format version
    minor_version : int
        minor MATLAB file format version
    
    Raises
    ------
    MatReadError
        If the file is empty.
    ValueError
        The matfile version is unknown.
    
    Notes
    -----
    Has the side effect of setting the file read pointer to 0
",function,"('(fileobj)',)",scipy,1.1.0,scipy.io.matlab.mio.get_matfile_version,io.matlab.mio,get_matfile_version,"Python Library Documentation: function get_matfile_version in module scipy.io.matlab.miobase

get_matfile_version(fileobj)
    Return major, minor tuple depending on apparent mat file type
    
    Where:
    
     #. 0,x -> version 4 format mat files
     #. 1,x -> version 5 format mat files
     #. 2,x -> version 7.3 format mat files (HDF format)
    
    Parameters
    ----------
    fileobj : file_like
        object implementing seek() and read()
    
    Returns
    -------
    major_version : {0, 1, 2}
        major MATLAB File format version
    minor_version : int
        minor MATLAB file format version
    
    Raises
    ------
    MatReadError
        If the file is empty.
    ValueError
        The matfile version is unknown.
    
    Notes
    -----
    Has the side effect of setting the file read pointer to 0
",function,"('fileobj',)","(nan,)","(nan,)","('arg_info',)","('(fileobj)',)"
scipy,1.1.0,scipy.io.matlab.mio.loadmat,io.matlab.mio,loadmat,"Python Library Documentation: function loadmat in module scipy.io.matlab.mio

loadmat(file_name, mdict=None, appendmat=True, **kwargs)
    Load MATLAB file.
    
    Parameters
    ----------
    file_name : str
       Name of the mat file (do not need .mat extension if
       appendmat==True). Can also pass open file-like object.
    mdict : dict, optional
        Dictionary in which to insert matfile variables.
    appendmat : bool, optional
       True to append the .mat extension to the end of the given
       filename, if not already present.
    byte_order : str or None, optional
       None by default, implying byte order guessed from mat
       file. Otherwise can be one of ('native', '=', 'little', '<',
       'BIG', '>').
    mat_dtype : bool, optional
       If True, return arrays in same dtype as would be loaded into
       MATLAB (instead of the dtype with which they are saved).
    squeeze_me : bool, optional
       Whether to squeeze unit matrix dimensions or not.
    chars_as_strings : bool, optional
       Whether to convert char arrays to string arrays.
    matlab_compatible : bool, optional
       Returns matrices as would be loaded by MATLAB (implies
       squeeze_me=False, chars_as_strings=False, mat_dtype=True,
       struct_as_record=True).
    struct_as_record : bool, optional
       Whether to load MATLAB structs as numpy record arrays, or as
       old-style numpy arrays with dtype=object.  Setting this flag to
       False replicates the behavior of scipy version 0.7.x (returning
       numpy object arrays).  The default setting is True, because it
       allows easier round-trip load and save of MATLAB files.
    verify_compressed_data_integrity : bool, optional
        Whether the length of compressed sequences in the MATLAB file
        should be checked, to ensure that they are not longer than we expect.
        It is advisable to enable this (the default) because overlong
        compressed sequences in MATLAB files generally indicate that the
        files have experienced some sort of corruption.
    variable_names : None or sequence
        If None (the default) - read all variables in file. Otherwise
        `variable_names` should be a sequence of strings, giving names of the
        matlab variables to read from the file.  The reader will skip any
        variable with a name not in this sequence, possibly saving some read
        processing.
    
    Returns
    -------
    mat_dict : dict
       dictionary with variable names as keys, and loaded matrices as
       values.
    
    Notes
    -----
    v4 (Level 1.0), v6 and v7 to 7.2 matfiles are supported.
    
    You will need an HDF5 python library to read matlab 7.3 format mat
    files.  Because scipy does not supply one, we do not implement the
    HDF5 / 7.3 interface here.
",function,"('(file_name, mdict=None, appendmat=True, **kwargs)',)",scipy,1.1.0,scipy.io.matlab.mio.loadmat,io.matlab.mio,loadmat,"Python Library Documentation: function loadmat in module scipy.io.matlab.mio

loadmat(file_name, mdict=None, appendmat=True, **kwargs)
    Load MATLAB file.
    
    Parameters
    ----------
    file_name : str
       Name of the mat file (do not need .mat extension if
       appendmat==True). Can also pass open file-like object.
    mdict : dict, optional
        Dictionary in which to insert matfile variables.
    appendmat : bool, optional
       True to append the .mat extension to the end of the given
       filename, if not already present.
    byte_order : str or None, optional
       None by default, implying byte order guessed from mat
       file. Otherwise can be one of ('native', '=', 'little', '<',
       'BIG', '>').
    mat_dtype : bool, optional
       If True, return arrays in same dtype as would be loaded into
       MATLAB (instead of the dtype with which they are saved).
    squeeze_me : bool, optional
       Whether to squeeze unit matrix dimensions or not.
    chars_as_strings : bool, optional
       Whether to convert char arrays to string arrays.
    matlab_compatible : bool, optional
       Returns matrices as would be loaded by MATLAB (implies
       squeeze_me=False, chars_as_strings=False, mat_dtype=True,
       struct_as_record=True).
    struct_as_record : bool, optional
       Whether to load MATLAB structs as numpy record arrays, or as
       old-style numpy arrays with dtype=object.  Setting this flag to
       False replicates the behavior of scipy version 0.7.x (returning
       numpy object arrays).  The default setting is True, because it
       allows easier round-trip load and save of MATLAB files.
    verify_compressed_data_integrity : bool, optional
        Whether the length of compressed sequences in the MATLAB file
        should be checked, to ensure that they are not longer than we expect.
        It is advisable to enable this (the default) because overlong
        compressed sequences in MATLAB files generally indicate that the
        files have experienced some sort of corruption.
    variable_names : None or sequence
        If None (the default) - read all variables in file. Otherwise
        `variable_names` should be a sequence of strings, giving names of the
        matlab variables to read from the file.  The reader will skip any
        variable with a name not in this sequence, possibly saving some read
        processing.
    
    Returns
    -------
    mat_dict : dict
       dictionary with variable names as keys, and loaded matrices as
       values.
    
    Notes
    -----
    v4 (Level 1.0), v6 and v7 to 7.2 matfiles are supported.
    
    You will need an HDF5 python library to read matlab 7.3 format mat
    files.  Because scipy does not supply one, we do not implement the
    HDF5 / 7.3 interface here.
",function,"('file_name', 'mdict', 'appendmat')","(nan, None, True)","(nan, 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info')","('(file_name, mdict=None, appendmat=True, **kwargs)',)"
scipy,1.1.0,scipy.io.matlab.mio.mat_reader_factory,io.matlab.mio,mat_reader_factory,"Python Library Documentation: function mat_reader_factory in module scipy.io.matlab.mio

mat_reader_factory(file_name, appendmat=True, **kwargs)
    Create reader for matlab .mat format files.
    
    Parameters
    ----------
    file_name : str
       Name of the mat file (do not need .mat extension if
       appendmat==True) Can also pass open file-like object.
    appendmat : bool, optional
       True to append the .mat extension to the end of the given
       filename, if not already present.
    byte_order : str or None, optional
       None by default, implying byte order guessed from mat
       file. Otherwise can be one of ('native', '=', 'little', '<',
       'BIG', '>').
    mat_dtype : bool, optional
       If True, return arrays in same dtype as would be loaded into
       MATLAB (instead of the dtype with which they are saved).
    squeeze_me : bool, optional
       Whether to squeeze unit matrix dimensions or not.
    chars_as_strings : bool, optional
       Whether to convert char arrays to string arrays.
    matlab_compatible : bool, optional
       Returns matrices as would be loaded by MATLAB (implies
       squeeze_me=False, chars_as_strings=False, mat_dtype=True,
       struct_as_record=True).
    struct_as_record : bool, optional
       Whether to load MATLAB structs as numpy record arrays, or as
       old-style numpy arrays with dtype=object.  Setting this flag to
       False replicates the behavior of scipy version 0.7.x (returning
       numpy object arrays).  The default setting is True, because it
       allows easier round-trip load and save of MATLAB files.
    
    Returns
    -------
    matreader : MatFileReader object
       Initialized instance of MatFileReader class matching the mat file
       type detected in `filename`.
    file_opened : bool
       Whether the file was opened by this routine.
",function,"('(file_name, appendmat=True, **kwargs)',)",scipy,1.1.0,scipy.io.matlab.mio.mat_reader_factory,io.matlab.mio,mat_reader_factory,"Python Library Documentation: function mat_reader_factory in module scipy.io.matlab.mio

mat_reader_factory(file_name, appendmat=True, **kwargs)
    Create reader for matlab .mat format files.
    
    Parameters
    ----------
    file_name : str
       Name of the mat file (do not need .mat extension if
       appendmat==True) Can also pass open file-like object.
    appendmat : bool, optional
       True to append the .mat extension to the end of the given
       filename, if not already present.
    byte_order : str or None, optional
       None by default, implying byte order guessed from mat
       file. Otherwise can be one of ('native', '=', 'little', '<',
       'BIG', '>').
    mat_dtype : bool, optional
       If True, return arrays in same dtype as would be loaded into
       MATLAB (instead of the dtype with which they are saved).
    squeeze_me : bool, optional
       Whether to squeeze unit matrix dimensions or not.
    chars_as_strings : bool, optional
       Whether to convert char arrays to string arrays.
    matlab_compatible : bool, optional
       Returns matrices as would be loaded by MATLAB (implies
       squeeze_me=False, chars_as_strings=False, mat_dtype=True,
       struct_as_record=True).
    struct_as_record : bool, optional
       Whether to load MATLAB structs as numpy record arrays, or as
       old-style numpy arrays with dtype=object.  Setting this flag to
       False replicates the behavior of scipy version 0.7.x (returning
       numpy object arrays).  The default setting is True, because it
       allows easier round-trip load and save of MATLAB files.
    
    Returns
    -------
    matreader : MatFileReader object
       Initialized instance of MatFileReader class matching the mat file
       type detected in `filename`.
    file_opened : bool
       Whether the file was opened by this routine.
",function,"('file_name', 'appendmat')","(nan, True)","(nan, 'bool')","('arg_info', 'arg_info')","('(file_name, appendmat=True, **kwargs)',)"
scipy,1.1.0,scipy.io.matlab.mio.savemat,io.matlab.mio,savemat,"Python Library Documentation: function savemat in module scipy.io.matlab.mio

savemat(file_name, mdict, appendmat=True, format='5', long_field_names=False, do_compression=False, oned_as='row')
    Save a dictionary of names and arrays into a MATLAB-style .mat file.
    
    This saves the array objects in the given dictionary to a MATLAB-
    style .mat file.
    
    Parameters
    ----------
    file_name : str or file-like object
        Name of the .mat file (.mat extension not needed if ``appendmat ==
        True``).
        Can also pass open file_like object.
    mdict : dict
        Dictionary from which to save matfile variables.
    appendmat : bool, optional
        True (the default) to append the .mat extension to the end of the
        given filename, if not already present.
    format : {'5', '4'}, string, optional
        '5' (the default) for MATLAB 5 and up (to 7.2),
        '4' for MATLAB 4 .mat files.
    long_field_names : bool, optional
        False (the default) - maximum field name length in a structure is
        31 characters which is the documented maximum length.
        True - maximum field name length in a structure is 63 characters
        which works for MATLAB 7.6+.
    do_compression : bool, optional
        Whether or not to compress matrices on write.  Default is False.
    oned_as : {'row', 'column'}, optional
        If 'column', write 1-D numpy arrays as column vectors.
        If 'row', write 1-D numpy arrays as row vectors.
    
    See also
    --------
    mio4.MatFile4Writer
    mio5.MatFile5Writer
",function,"(""(file_name, mdict, appendmat=True, format='5', long_field_names=False, do_compression=False, oned_as='row')"",)",scipy,1.1.0,scipy.io.matlab.mio.savemat,io.matlab.mio,savemat,"Python Library Documentation: function savemat in module scipy.io.matlab.mio

savemat(file_name, mdict, appendmat=True, format='5', long_field_names=False, do_compression=False, oned_as='row')
    Save a dictionary of names and arrays into a MATLAB-style .mat file.
    
    This saves the array objects in the given dictionary to a MATLAB-
    style .mat file.
    
    Parameters
    ----------
    file_name : str or file-like object
        Name of the .mat file (.mat extension not needed if ``appendmat ==
        True``).
        Can also pass open file_like object.
    mdict : dict
        Dictionary from which to save matfile variables.
    appendmat : bool, optional
        True (the default) to append the .mat extension to the end of the
        given filename, if not already present.
    format : {'5', '4'}, string, optional
        '5' (the default) for MATLAB 5 and up (to 7.2),
        '4' for MATLAB 4 .mat files.
    long_field_names : bool, optional
        False (the default) - maximum field name length in a structure is
        31 characters which is the documented maximum length.
        True - maximum field name length in a structure is 63 characters
        which works for MATLAB 7.6+.
    do_compression : bool, optional
        Whether or not to compress matrices on write.  Default is False.
    oned_as : {'row', 'column'}, optional
        If 'column', write 1-D numpy arrays as column vectors.
        If 'row', write 1-D numpy arrays as row vectors.
    
    See also
    --------
    mio4.MatFile4Writer
    mio5.MatFile5Writer
",function,"('file_name', 'mdict', 'appendmat', 'format', 'long_field_names', 'do_compression', 'oned_as')","(nan, nan, True, '5', False, False, 'row')","(nan, nan, 'bool', 'int', 'bool', 'bool', 'str')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(file_name, mdict, appendmat=True, format='5', long_field_names=False, do_compression=False, oned_as='row')"",)"
scipy,1.1.0,scipy.io.matlab.mio.whosmat,io.matlab.mio,whosmat,"Python Library Documentation: function whosmat in module scipy.io.matlab.mio

whosmat(file_name, appendmat=True, **kwargs)
    List variables inside a MATLAB file.
    
    Parameters
    ----------
    file_name : str
       Name of the mat file (do not need .mat extension if
       appendmat==True) Can also pass open file-like object.
    appendmat : bool, optional
       True to append the .mat extension to the end of the given
       filename, if not already present.
    byte_order : str or None, optional
       None by default, implying byte order guessed from mat
       file. Otherwise can be one of ('native', '=', 'little', '<',
       'BIG', '>').
    mat_dtype : bool, optional
       If True, return arrays in same dtype as would be loaded into
       MATLAB (instead of the dtype with which they are saved).
    squeeze_me : bool, optional
       Whether to squeeze unit matrix dimensions or not.
    chars_as_strings : bool, optional
       Whether to convert char arrays to string arrays.
    matlab_compatible : bool, optional
       Returns matrices as would be loaded by MATLAB (implies
       squeeze_me=False, chars_as_strings=False, mat_dtype=True,
       struct_as_record=True).
    struct_as_record : bool, optional
       Whether to load MATLAB structs as numpy record arrays, or as
       old-style numpy arrays with dtype=object.  Setting this flag to
       False replicates the behavior of scipy version 0.7.x (returning
       numpy object arrays).  The default setting is True, because it
       allows easier round-trip load and save of MATLAB files.
    
    Returns
    -------
    variables : list of tuples
        A list of tuples, where each tuple holds the matrix name (a string),
        its shape (tuple of ints), and its data class (a string).
        Possible data classes are: int8, uint8, int16, uint16, int32, uint32,
        int64, uint64, single, double, cell, struct, object, char, sparse,
        function, opaque, logical, unknown.
    
    Notes
    -----
    v4 (Level 1.0), v6 and v7 to 7.2 matfiles are supported.
    
    You will need an HDF5 python library to read matlab 7.3 format mat
    files.  Because scipy does not supply one, we do not implement the
    HDF5 / 7.3 interface here.
    
    .. versionadded:: 0.12.0
",function,"('(file_name, appendmat=True, **kwargs)',)",scipy,1.1.0,scipy.io.matlab.mio.whosmat,io.matlab.mio,whosmat,"Python Library Documentation: function whosmat in module scipy.io.matlab.mio

whosmat(file_name, appendmat=True, **kwargs)
    List variables inside a MATLAB file.
    
    Parameters
    ----------
    file_name : str
       Name of the mat file (do not need .mat extension if
       appendmat==True) Can also pass open file-like object.
    appendmat : bool, optional
       True to append the .mat extension to the end of the given
       filename, if not already present.
    byte_order : str or None, optional
       None by default, implying byte order guessed from mat
       file. Otherwise can be one of ('native', '=', 'little', '<',
       'BIG', '>').
    mat_dtype : bool, optional
       If True, return arrays in same dtype as would be loaded into
       MATLAB (instead of the dtype with which they are saved).
    squeeze_me : bool, optional
       Whether to squeeze unit matrix dimensions or not.
    chars_as_strings : bool, optional
       Whether to convert char arrays to string arrays.
    matlab_compatible : bool, optional
       Returns matrices as would be loaded by MATLAB (implies
       squeeze_me=False, chars_as_strings=False, mat_dtype=True,
       struct_as_record=True).
    struct_as_record : bool, optional
       Whether to load MATLAB structs as numpy record arrays, or as
       old-style numpy arrays with dtype=object.  Setting this flag to
       False replicates the behavior of scipy version 0.7.x (returning
       numpy object arrays).  The default setting is True, because it
       allows easier round-trip load and save of MATLAB files.
    
    Returns
    -------
    variables : list of tuples
        A list of tuples, where each tuple holds the matrix name (a string),
        its shape (tuple of ints), and its data class (a string).
        Possible data classes are: int8, uint8, int16, uint16, int32, uint32,
        int64, uint64, single, double, cell, struct, object, char, sparse,
        function, opaque, logical, unknown.
    
    Notes
    -----
    v4 (Level 1.0), v6 and v7 to 7.2 matfiles are supported.
    
    You will need an HDF5 python library to read matlab 7.3 format mat
    files.  Because scipy does not supply one, we do not implement the
    HDF5 / 7.3 interface here.
    
    .. versionadded:: 0.12.0
",function,"('file_name', 'appendmat')","(nan, True)","(nan, 'bool')","('arg_info', 'arg_info')","('(file_name, appendmat=True, **kwargs)',)"
scipy,1.1.0,scipy.io.matlab.mio4.MatFile4Reader,io.matlab.mio4,MatFile4Reader,"Python Library Documentation: class MatFile4Reader in module scipy.io.matlab.mio4

class MatFile4Reader(scipy.io.matlab.miobase.MatFileReader)
 |  Reader for Mat4 files
 |  
 |  Method resolution order:
 |      MatFile4Reader
 |      scipy.io.matlab.miobase.MatFileReader
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, mat_stream, *args, **kwargs)
 |      Initialize matlab 4 file reader
 |      
 |      mat_stream : file-like
 |         Object with file API, open for reading.
 |      byte_order : str or None, optional
 |         None by default, implying byte order guessed from mat
 |         file. Otherwise can be one of ('native', '=', 'little', '<',
 |         'BIG', '>').
 |      mat_dtype : bool, optional
 |         If True, return arrays in same dtype as would be loaded into
 |         MATLAB (instead of the dtype with which they are saved).
 |      squeeze_me : bool, optional
 |         Whether to squeeze unit matrix dimensions or not.
 |      chars_as_strings : bool, optional
 |         Whether to convert char arrays to string arrays.
 |      matlab_compatible : bool, optional
 |         Returns matrices as would be loaded by MATLAB (implies
 |         squeeze_me=False, chars_as_strings=False, mat_dtype=True,
 |         struct_as_record=True).
 |  
 |  get_variables(self, variable_names=None)
 |      get variables from stream as dictionary
 |      
 |      Parameters
 |      ----------
 |      variable_names : None or str or sequence of str, optional
 |          variable name, or sequence of variable names to get from Mat file /
 |          file stream.  If None, then get all variables in file
 |  
 |  guess_byte_order(self)
 |      As we do not know what file type we have, assume native
 |  
 |  initialize_read(self)
 |      Run when beginning read of variables
 |      
 |      Sets up readers from parameters in `self`
 |  
 |  list_variables(self)
 |      list variables from stream
 |  
 |  read_var_array(self, header, process=True)
 |      Read array, given `header`
 |      
 |      Parameters
 |      ----------
 |      header : header object
 |         object with fields defining variable header
 |      process : {True, False}, optional
 |         If True, apply recursive post-processing during loading of array.
 |      
 |      Returns
 |      -------
 |      arr : array
 |         array with post-processing applied or not according to
 |         `process`.
 |  
 |  read_var_header(self)
 |      Read and return header, next position
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      header : object
 |         object that can be passed to self.read_var_array, and that
 |         has attributes ``name`` and ``is_global``
 |      next_position : int
 |         position in stream of next variable
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.io.matlab.miobase.MatFileReader:
 |  
 |  end_of_stream(self)
 |  
 |  set_matlab_compatible(self)
 |      Sets options to return arrays as MATLAB loads them
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.io.matlab.miobase.MatFileReader:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, mat_stream, *args, **kwargs)',)",scipy,1.1.0,scipy.io.matlab.mio4.MatFile4Reader,io.matlab.mio4,MatFile4Reader,"Python Library Documentation: class MatFile4Reader in module scipy.io.matlab.mio4

class MatFile4Reader(scipy.io.matlab.miobase.MatFileReader)
 |  Reader for Mat4 files
 |  
 |  Method resolution order:
 |      MatFile4Reader
 |      scipy.io.matlab.miobase.MatFileReader
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, mat_stream, *args, **kwargs)
 |      Initialize matlab 4 file reader
 |      
 |      mat_stream : file-like
 |         Object with file API, open for reading.
 |      byte_order : str or None, optional
 |         None by default, implying byte order guessed from mat
 |         file. Otherwise can be one of ('native', '=', 'little', '<',
 |         'BIG', '>').
 |      mat_dtype : bool, optional
 |         If True, return arrays in same dtype as would be loaded into
 |         MATLAB (instead of the dtype with which they are saved).
 |      squeeze_me : bool, optional
 |         Whether to squeeze unit matrix dimensions or not.
 |      chars_as_strings : bool, optional
 |         Whether to convert char arrays to string arrays.
 |      matlab_compatible : bool, optional
 |         Returns matrices as would be loaded by MATLAB (implies
 |         squeeze_me=False, chars_as_strings=False, mat_dtype=True,
 |         struct_as_record=True).
 |  
 |  get_variables(self, variable_names=None)
 |      get variables from stream as dictionary
 |      
 |      Parameters
 |      ----------
 |      variable_names : None or str or sequence of str, optional
 |          variable name, or sequence of variable names to get from Mat file /
 |          file stream.  If None, then get all variables in file
 |  
 |  guess_byte_order(self)
 |      As we do not know what file type we have, assume native
 |  
 |  initialize_read(self)
 |      Run when beginning read of variables
 |      
 |      Sets up readers from parameters in `self`
 |  
 |  list_variables(self)
 |      list variables from stream
 |  
 |  read_var_array(self, header, process=True)
 |      Read array, given `header`
 |      
 |      Parameters
 |      ----------
 |      header : header object
 |         object with fields defining variable header
 |      process : {True, False}, optional
 |         If True, apply recursive post-processing during loading of array.
 |      
 |      Returns
 |      -------
 |      arr : array
 |         array with post-processing applied or not according to
 |         `process`.
 |  
 |  read_var_header(self)
 |      Read and return header, next position
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      header : object
 |         object that can be passed to self.read_var_array, and that
 |         has attributes ``name`` and ``is_global``
 |      next_position : int
 |         position in stream of next variable
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.io.matlab.miobase.MatFileReader:
 |  
 |  end_of_stream(self)
 |  
 |  set_matlab_compatible(self)
 |      Sets options to return arrays as MATLAB loads them
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.io.matlab.miobase.MatFileReader:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'mat_stream')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(self, mat_stream, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.matlab.mio4.MatFile4Writer,io.matlab.mio4,MatFile4Writer,"Python Library Documentation: class MatFile4Writer in module scipy.io.matlab.mio4

class MatFile4Writer(builtins.object)
 |  Class for writing matlab 4 format files
 |  
 |  Methods defined here:
 |  
 |  __init__(self, file_stream, oned_as=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  put_variables(self, mdict, write_header=None)
 |      Write variables in `mdict` to stream
 |      
 |      Parameters
 |      ----------
 |      mdict : mapping
 |         mapping with method ``items`` return name, contents pairs
 |         where ``name`` which will appeak in the matlab workspace in
 |         file load, and ``contents`` is something writeable to a
 |         matlab file, such as a numpy array.
 |      write_header : {None, True, False}
 |         If True, then write the matlab file header before writing the
 |         variables.  If None (the default) then write the file header
 |         if we are at position 0 in the stream.  By setting False
 |         here, and setting the stream position to the end of the file,
 |         you can append variables to a matlab file
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, file_stream, oned_as=None)',)",scipy,1.1.0,scipy.io.matlab.mio4.MatFile4Writer,io.matlab.mio4,MatFile4Writer,"Python Library Documentation: class MatFile4Writer in module scipy.io.matlab.mio4

class MatFile4Writer(builtins.object)
 |  Class for writing matlab 4 format files
 |  
 |  Methods defined here:
 |  
 |  __init__(self, file_stream, oned_as=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  put_variables(self, mdict, write_header=None)
 |      Write variables in `mdict` to stream
 |      
 |      Parameters
 |      ----------
 |      mdict : mapping
 |         mapping with method ``items`` return name, contents pairs
 |         where ``name`` which will appeak in the matlab workspace in
 |         file load, and ``contents`` is something writeable to a
 |         matlab file, such as a numpy array.
 |      write_header : {None, True, False}
 |         If True, then write the matlab file header before writing the
 |         variables.  If None (the default) then write the file header
 |         if we are at position 0 in the stream.  By setting False
 |         here, and setting the stream position to the end of the file,
 |         you can append variables to a matlab file
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'file_stream', 'oned_as')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(self, file_stream, oned_as=None)',)"
scipy,1.1.0,scipy.io.matlab.mio4.MatFileReader,io.matlab.mio4,MatFileReader,"Python Library Documentation: class MatFileReader in module scipy.io.matlab.miobase

class MatFileReader(builtins.object)
 |  Base object for reading mat files
 |  
 |  To make this class functional, you will need to override the
 |  following methods:
 |  
 |  matrix_getter_factory   - gives object to fetch next matrix from stream
 |  guess_byte_order        - guesses file byte order from file
 |  
 |  Methods defined here:
 |  
 |  __init__(self, mat_stream, byte_order=None, mat_dtype=False, squeeze_me=False, chars_as_strings=True, matlab_compatible=False, struct_as_record=True, verify_compressed_data_integrity=True)
 |          Initializer for mat file reader
 |      
 |          mat_stream : file-like
 |              object with file API, open for reading
 |      byte_order : str or None, optional
 |         None by default, implying byte order guessed from mat
 |         file. Otherwise can be one of ('native', '=', 'little', '<',
 |         'BIG', '>').
 |      mat_dtype : bool, optional
 |         If True, return arrays in same dtype as would be loaded into
 |         MATLAB (instead of the dtype with which they are saved).
 |      squeeze_me : bool, optional
 |         Whether to squeeze unit matrix dimensions or not.
 |      chars_as_strings : bool, optional
 |         Whether to convert char arrays to string arrays.
 |      matlab_compatible : bool, optional
 |         Returns matrices as would be loaded by MATLAB (implies
 |         squeeze_me=False, chars_as_strings=False, mat_dtype=True,
 |         struct_as_record=True).
 |  
 |  end_of_stream(self)
 |  
 |  guess_byte_order(self)
 |      As we do not know what file type we have, assume native
 |  
 |  set_matlab_compatible(self)
 |      Sets options to return arrays as MATLAB loads them
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, mat_stream, byte_order=None, mat_dtype=False, squeeze_me=False, chars_as_strings=True, matlab_compatible=False, struct_as_record=True, verify_compressed_data_integrity=True)',)",scipy,1.1.0,scipy.io.matlab.mio4.MatFileReader,io.matlab.mio4,MatFileReader,"Python Library Documentation: class MatFileReader in module scipy.io.matlab.miobase

class MatFileReader(builtins.object)
 |  Base object for reading mat files
 |  
 |  To make this class functional, you will need to override the
 |  following methods:
 |  
 |  matrix_getter_factory   - gives object to fetch next matrix from stream
 |  guess_byte_order        - guesses file byte order from file
 |  
 |  Methods defined here:
 |  
 |  __init__(self, mat_stream, byte_order=None, mat_dtype=False, squeeze_me=False, chars_as_strings=True, matlab_compatible=False, struct_as_record=True, verify_compressed_data_integrity=True)
 |          Initializer for mat file reader
 |      
 |          mat_stream : file-like
 |              object with file API, open for reading
 |      byte_order : str or None, optional
 |         None by default, implying byte order guessed from mat
 |         file. Otherwise can be one of ('native', '=', 'little', '<',
 |         'BIG', '>').
 |      mat_dtype : bool, optional
 |         If True, return arrays in same dtype as would be loaded into
 |         MATLAB (instead of the dtype with which they are saved).
 |      squeeze_me : bool, optional
 |         Whether to squeeze unit matrix dimensions or not.
 |      chars_as_strings : bool, optional
 |         Whether to convert char arrays to string arrays.
 |      matlab_compatible : bool, optional
 |         Returns matrices as would be loaded by MATLAB (implies
 |         squeeze_me=False, chars_as_strings=False, mat_dtype=True,
 |         struct_as_record=True).
 |  
 |  end_of_stream(self)
 |  
 |  guess_byte_order(self)
 |      As we do not know what file type we have, assume native
 |  
 |  set_matlab_compatible(self)
 |      Sets options to return arrays as MATLAB loads them
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'mat_stream', 'byte_order', 'mat_dtype', 'squeeze_me', 'chars_as_strings', 'matlab_compatible', 'struct_as_record', 'verify_compressed_data_integrity')","(nan, nan, None, False, False, True, False, True, True)","(nan, nan, 'NoneType', 'bool', 'bool', 'bool', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, mat_stream, byte_order=None, mat_dtype=False, squeeze_me=False, chars_as_strings=True, matlab_compatible=False, struct_as_record=True, verify_compressed_data_integrity=True)',)"
scipy,1.1.0,scipy.io.matlab.mio4.VarHeader4,io.matlab.mio4,VarHeader4,"Python Library Documentation: class VarHeader4 in module scipy.io.matlab.mio4

class VarHeader4(builtins.object)
 |  Methods defined here:
 |  
 |  __init__(self, name, dtype, mclass, dims, is_complex)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  is_global = False
 |  
 |  is_logical = False
",class,"('(self, name, dtype, mclass, dims, is_complex)',)",scipy,1.1.0,scipy.io.matlab.mio4.VarHeader4,io.matlab.mio4,VarHeader4,"Python Library Documentation: class VarHeader4 in module scipy.io.matlab.mio4

class VarHeader4(builtins.object)
 |  Methods defined here:
 |  
 |  __init__(self, name, dtype, mclass, dims, is_complex)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  is_global = False
 |  
 |  is_logical = False
",class,"('self', 'name', 'dtype', 'mclass', 'dims', 'is_complex')","(nan, nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, name, dtype, mclass, dims, is_complex)',)"
scipy,1.1.0,scipy.io.matlab.mio4.VarReader4,io.matlab.mio4,VarReader4,"Python Library Documentation: class VarReader4 in module scipy.io.matlab.mio4

class VarReader4(builtins.object)
 |  Class to read matlab 4 variables
 |  
 |  Methods defined here:
 |  
 |  __init__(self, file_reader)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  array_from_header(self, hdr, process=True)
 |  
 |  read_char_array(self, hdr)
 |      latin-1 text matrix (char matrix) reader
 |      
 |      Parameters
 |      ----------
 |      hdr : ``VarHeader4`` instance
 |      
 |      Returns
 |      -------
 |      arr : ndarray
 |          with dtype 'U1', shape given by `hdr` ``dims``
 |  
 |  read_full_array(self, hdr)
 |      Full (rather than sparse) matrix getter
 |      
 |      Read matrix (array) can be real or complex
 |      
 |      Parameters
 |      ----------
 |      hdr : ``VarHeader4`` instance
 |      
 |      Returns
 |      -------
 |      arr : ndarray
 |          complex array if ``hdr.is_complex`` is True, otherwise a real
 |          numeric array
 |  
 |  read_header(self)
 |      Read and return header for variable
 |  
 |  read_sparse_array(self, hdr)
 |      Read and return sparse matrix type
 |      
 |      Parameters
 |      ----------
 |      hdr : ``VarHeader4`` instance
 |      
 |      Returns
 |      -------
 |      arr : ``scipy.sparse.coo_matrix``
 |          with dtype ``float`` and shape read from the sparse matrix data
 |      
 |      Notes
 |      -----
 |      MATLAB 4 real sparse arrays are saved in a N+1 by 3 array format, where
 |      N is the number of non-zero values.  Column 1 values [0:N] are the
 |      (1-based) row indices of the each non-zero value, column 2 [0:N] are the
 |      column indices, column 3 [0:N] are the (real) values.  The last values
 |      [-1,0:2] of the rows, column indices are shape[0] and shape[1]
 |      respectively of the output matrix. The last value for the values column
 |      is a padding 0. mrows and ncols values from the header give the shape of
 |      the stored matrix, here [N+1, 3].  Complex data is saved as a 4 column
 |      matrix, where the fourth column contains the imaginary component; the
 |      last value is again 0.  Complex sparse data do *not* have the header
 |      ``imagf`` field set to True; the fact that the data are complex is only
 |      detectable because there are 4 storage columns
 |  
 |  read_sub_array(self, hdr, copy=True)
 |      Mat4 read using header `hdr` dtype and dims
 |      
 |      Parameters
 |      ----------
 |      hdr : object
 |         object with attributes ``dtype``, ``dims``.  dtype is assumed to be
 |         the correct endianness
 |      copy : bool, optional
 |         copies array before return if True (default True)
 |         (buffer is usually read only)
 |      
 |      Returns
 |      -------
 |      arr : ndarray
 |          of dtype givem by `hdr` ``dtype`` and shape givem by `hdr` ``dims``
 |  
 |  shape_from_header(self, hdr)
 |      Read the shape of the array described by the header.
 |      The file position after this call is unspecified.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, file_reader)',)",scipy,1.1.0,scipy.io.matlab.mio4.VarReader4,io.matlab.mio4,VarReader4,"Python Library Documentation: class VarReader4 in module scipy.io.matlab.mio4

class VarReader4(builtins.object)
 |  Class to read matlab 4 variables
 |  
 |  Methods defined here:
 |  
 |  __init__(self, file_reader)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  array_from_header(self, hdr, process=True)
 |  
 |  read_char_array(self, hdr)
 |      latin-1 text matrix (char matrix) reader
 |      
 |      Parameters
 |      ----------
 |      hdr : ``VarHeader4`` instance
 |      
 |      Returns
 |      -------
 |      arr : ndarray
 |          with dtype 'U1', shape given by `hdr` ``dims``
 |  
 |  read_full_array(self, hdr)
 |      Full (rather than sparse) matrix getter
 |      
 |      Read matrix (array) can be real or complex
 |      
 |      Parameters
 |      ----------
 |      hdr : ``VarHeader4`` instance
 |      
 |      Returns
 |      -------
 |      arr : ndarray
 |          complex array if ``hdr.is_complex`` is True, otherwise a real
 |          numeric array
 |  
 |  read_header(self)
 |      Read and return header for variable
 |  
 |  read_sparse_array(self, hdr)
 |      Read and return sparse matrix type
 |      
 |      Parameters
 |      ----------
 |      hdr : ``VarHeader4`` instance
 |      
 |      Returns
 |      -------
 |      arr : ``scipy.sparse.coo_matrix``
 |          with dtype ``float`` and shape read from the sparse matrix data
 |      
 |      Notes
 |      -----
 |      MATLAB 4 real sparse arrays are saved in a N+1 by 3 array format, where
 |      N is the number of non-zero values.  Column 1 values [0:N] are the
 |      (1-based) row indices of the each non-zero value, column 2 [0:N] are the
 |      column indices, column 3 [0:N] are the (real) values.  The last values
 |      [-1,0:2] of the rows, column indices are shape[0] and shape[1]
 |      respectively of the output matrix. The last value for the values column
 |      is a padding 0. mrows and ncols values from the header give the shape of
 |      the stored matrix, here [N+1, 3].  Complex data is saved as a 4 column
 |      matrix, where the fourth column contains the imaginary component; the
 |      last value is again 0.  Complex sparse data do *not* have the header
 |      ``imagf`` field set to True; the fact that the data are complex is only
 |      detectable because there are 4 storage columns
 |  
 |  read_sub_array(self, hdr, copy=True)
 |      Mat4 read using header `hdr` dtype and dims
 |      
 |      Parameters
 |      ----------
 |      hdr : object
 |         object with attributes ``dtype``, ``dims``.  dtype is assumed to be
 |         the correct endianness
 |      copy : bool, optional
 |         copies array before return if True (default True)
 |         (buffer is usually read only)
 |      
 |      Returns
 |      -------
 |      arr : ndarray
 |          of dtype givem by `hdr` ``dtype`` and shape givem by `hdr` ``dims``
 |  
 |  shape_from_header(self, hdr)
 |      Read the shape of the array described by the header.
 |      The file position after this call is unspecified.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'file_reader')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(self, file_reader)',)"
scipy,1.1.0,scipy.io.matlab.mio4.VarWriter4,io.matlab.mio4,VarWriter4,"Python Library Documentation: class VarWriter4 in module scipy.io.matlab.mio4

class VarWriter4(builtins.object)
 |  Methods defined here:
 |  
 |  __init__(self, file_writer)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  write(self, arr, name)
 |      Write matrix `arr`, with name `name`
 |      
 |      Parameters
 |      ----------
 |      arr : array_like
 |         array to write
 |      name : str
 |         name in matlab workspace
 |  
 |  write_bytes(self, arr)
 |  
 |  write_char(self, arr, name)
 |  
 |  write_header(self, name, shape, P=0, T=0, imagf=0)
 |      Write header for given data options
 |      
 |      Parameters
 |      ----------
 |      name : str
 |          name of variable
 |      shape : sequence
 |         Shape of array as it will be read in matlab
 |      P : int, optional
 |          code for mat4 data type, one of ``miDOUBLE, miSINGLE, miINT32,
 |          miINT16, miUINT16, miUINT8``
 |      T : int, optional
 |          code for mat4 matrix class, one of ``mxFULL_CLASS, mxCHAR_CLASS,
 |          mxSPARSE_CLASS``
 |      imagf : int, optional
 |          flag indicating complex
 |  
 |  write_numeric(self, arr, name)
 |  
 |  write_sparse(self, arr, name)
 |      Sparse matrices are 2D
 |      
 |      See docstring for VarReader4.read_sparse_array
 |  
 |  write_string(self, s)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, file_writer)',)",scipy,1.1.0,scipy.io.matlab.mio4.VarWriter4,io.matlab.mio4,VarWriter4,"Python Library Documentation: class VarWriter4 in module scipy.io.matlab.mio4

class VarWriter4(builtins.object)
 |  Methods defined here:
 |  
 |  __init__(self, file_writer)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  write(self, arr, name)
 |      Write matrix `arr`, with name `name`
 |      
 |      Parameters
 |      ----------
 |      arr : array_like
 |         array to write
 |      name : str
 |         name in matlab workspace
 |  
 |  write_bytes(self, arr)
 |  
 |  write_char(self, arr, name)
 |  
 |  write_header(self, name, shape, P=0, T=0, imagf=0)
 |      Write header for given data options
 |      
 |      Parameters
 |      ----------
 |      name : str
 |          name of variable
 |      shape : sequence
 |         Shape of array as it will be read in matlab
 |      P : int, optional
 |          code for mat4 data type, one of ``miDOUBLE, miSINGLE, miINT32,
 |          miINT16, miUINT16, miUINT8``
 |      T : int, optional
 |          code for mat4 matrix class, one of ``mxFULL_CLASS, mxCHAR_CLASS,
 |          mxSPARSE_CLASS``
 |      imagf : int, optional
 |          flag indicating complex
 |  
 |  write_numeric(self, arr, name)
 |  
 |  write_sparse(self, arr, name)
 |      Sparse matrices are 2D
 |      
 |      See docstring for VarReader4.read_sparse_array
 |  
 |  write_string(self, s)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'file_writer')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(self, file_writer)',)"
scipy,1.1.0,scipy.io.matlab.mio4.arr_dtype_number,io.matlab.mio4,arr_dtype_number,"Python Library Documentation: function arr_dtype_number in module scipy.io.matlab.miobase

arr_dtype_number(arr, num)
    Return dtype for given number of items per element
",function,"('(arr, num)',)",scipy,1.1.0,scipy.io.matlab.mio4.arr_dtype_number,io.matlab.mio4,arr_dtype_number,"Python Library Documentation: function arr_dtype_number in module scipy.io.matlab.miobase

arr_dtype_number(arr, num)
    Return dtype for given number of items per element
",function,"('arr', 'num')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(arr, num)',)"
scipy,1.1.0,scipy.io.matlab.mio4.arr_to_2d,io.matlab.mio4,arr_to_2d,"Python Library Documentation: function arr_to_2d in module scipy.io.matlab.mio4

arr_to_2d(arr, oned_as='row')
    Make ``arr`` exactly two dimensional
    
    If `arr` has more than 2 dimensions, raise a ValueError
    
    Parameters
    ----------
    arr : array
    oned_as : {'row', 'column'}, optional
       Whether to reshape 1D vectors as row vectors or column vectors.
       See documentation for ``matdims`` for more detail
    
    Returns
    -------
    arr2d : array
       2D version of the array
",function,"(""(arr, oned_as='row')"",)",scipy,1.1.0,scipy.io.matlab.mio4.arr_to_2d,io.matlab.mio4,arr_to_2d,"Python Library Documentation: function arr_to_2d in module scipy.io.matlab.mio4

arr_to_2d(arr, oned_as='row')
    Make ``arr`` exactly two dimensional
    
    If `arr` has more than 2 dimensions, raise a ValueError
    
    Parameters
    ----------
    arr : array
    oned_as : {'row', 'column'}, optional
       Whether to reshape 1D vectors as row vectors or column vectors.
       See documentation for ``matdims`` for more detail
    
    Returns
    -------
    arr2d : array
       2D version of the array
",function,"('arr', 'oned_as')","(nan, 'row')","(nan, 'str')","('arg_info', 'arg_info')","(""(arr, oned_as='row')"",)"
scipy,1.1.0,scipy.io.matlab.mio4.arr_to_chars,io.matlab.mio4,arr_to_chars,"Python Library Documentation: function arr_to_chars in module scipy.io.matlab.miobase

arr_to_chars(arr)
    Convert string array to char array
",function,"('(arr)',)",scipy,1.1.0,scipy.io.matlab.mio4.arr_to_chars,io.matlab.mio4,arr_to_chars,"Python Library Documentation: function arr_to_chars in module scipy.io.matlab.miobase

arr_to_chars(arr)
    Convert string array to char array
",function,"('arr',)","(nan,)","(nan,)","('arg_info',)","('(arr)',)"
scipy,1.1.0,scipy.io.matlab.mio4.asbytes,io.matlab.mio4,asbytes,"Python Library Documentation: function asbytes in module numpy.compat.py3k

asbytes(s)
",function,"('(s)',)",scipy,1.1.0,scipy.io.matlab.mio4.asbytes,io.matlab.mio4,asbytes,"Python Library Documentation: function asbytes in module numpy.compat.py3k

asbytes(s)
",function,"('s',)","(nan,)","(nan,)","('arg_info',)","('(s)',)"
scipy,1.1.0,scipy.io.matlab.mio4.asstr,io.matlab.mio4,asstr,"Python Library Documentation: function asstr in module numpy.compat.py3k

asstr(s)
",function,"('(s)',)",scipy,1.1.0,scipy.io.matlab.mio4.asstr,io.matlab.mio4,asstr,"Python Library Documentation: function asstr in module numpy.compat.py3k

asstr(s)
",function,"('s',)","(nan,)","(nan,)","('arg_info',)","('(s)',)"
scipy,1.1.0,scipy.io.matlab.mio4.convert_dtypes,io.matlab.mio4,convert_dtypes,"Python Library Documentation: function convert_dtypes in module scipy.io.matlab.miobase

convert_dtypes(dtype_template, order_code)
    Convert dtypes in mapping to given order
    
    Parameters
    ----------
    dtype_template : mapping
       mapping with values returning numpy dtype from ``np.dtype(val)``
    order_code : str
       an order code suitable for using in ``dtype.newbyteorder()``
    
    Returns
    -------
    dtypes : mapping
       mapping where values have been replaced by
       ``np.dtype(val).newbyteorder(order_code)``
",function,"('(dtype_template, order_code)',)",scipy,1.1.0,scipy.io.matlab.mio4.convert_dtypes,io.matlab.mio4,convert_dtypes,"Python Library Documentation: function convert_dtypes in module scipy.io.matlab.miobase

convert_dtypes(dtype_template, order_code)
    Convert dtypes in mapping to given order
    
    Parameters
    ----------
    dtype_template : mapping
       mapping with values returning numpy dtype from ``np.dtype(val)``
    order_code : str
       an order code suitable for using in ``dtype.newbyteorder()``
    
    Returns
    -------
    dtypes : mapping
       mapping where values have been replaced by
       ``np.dtype(val).newbyteorder(order_code)``
",function,"('dtype_template', 'order_code')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(dtype_template, order_code)',)"
scipy,1.1.0,scipy.io.matlab.mio4.docfiller,io.matlab.mio4,decorate,"Python Library Documentation: function decorate in module scipy.misc.doccer

decorate(f)
",function,"('(f)',)",scipy,1.1.0,scipy.io.matlab.mio4.docfiller,io.matlab.mio4,decorate,"Python Library Documentation: function decorate in module scipy.misc.doccer

decorate(f)
",function,"('f',)","(nan,)","(nan,)","('arg_info',)","('(f)',)"
scipy,1.1.0,scipy.io.matlab.mio4.matdims,io.matlab.mio4,matdims,"Python Library Documentation: function matdims in module scipy.io.matlab.miobase

matdims(arr, oned_as='column')
    Determine equivalent MATLAB dimensions for given array
    
    Parameters
    ----------
    arr : ndarray
        Input array
    oned_as : {'column', 'row'}, optional
        Whether 1-D arrays are returned as MATLAB row or column matrices.
        Default is 'column'.
    
    Returns
    -------
    dims : tuple
        Shape tuple, in the form MATLAB expects it.
    
    Notes
    -----
    We had to decide what shape a 1 dimensional array would be by
    default.  ``np.atleast_2d`` thinks it is a row vector.  The
    default for a vector in MATLAB (e.g. ``>> 1:12``) is a row vector.
    
    Versions of scipy up to and including 0.11 resulted (accidentally)
    in 1-D arrays being read as column vectors.  For the moment, we
    maintain the same tradition here.
    
    Examples
    --------
    >>> matdims(np.array(1)) # numpy scalar
    (1, 1)
    >>> matdims(np.array([1])) # 1d array, 1 element
    (1, 1)
    >>> matdims(np.array([1,2])) # 1d array, 2 elements
    (2, 1)
    >>> matdims(np.array([[2],[3]])) # 2d array, column vector
    (2, 1)
    >>> matdims(np.array([[2,3]])) # 2d array, row vector
    (1, 2)
    >>> matdims(np.array([[[2,3]]])) # 3d array, rowish vector
    (1, 1, 2)
    >>> matdims(np.array([])) # empty 1d array
    (0, 0)
    >>> matdims(np.array([[]])) # empty 2d
    (0, 0)
    >>> matdims(np.array([[[]]])) # empty 3d
    (0, 0, 0)
    
    Optional argument flips 1-D shape behavior.
    
    >>> matdims(np.array([1,2]), 'row') # 1d array, 2 elements
    (1, 2)
    
    The argument has to make sense though
    
    >>> matdims(np.array([1,2]), 'bizarre')
    Traceback (most recent call last):
       ...
    ValueError: 1D option ""bizarre"" is strange
",function,"(""(arr, oned_as='column')"",)",scipy,1.1.0,scipy.io.matlab.mio4.matdims,io.matlab.mio4,matdims,"Python Library Documentation: function matdims in module scipy.io.matlab.miobase

matdims(arr, oned_as='column')
    Determine equivalent MATLAB dimensions for given array
    
    Parameters
    ----------
    arr : ndarray
        Input array
    oned_as : {'column', 'row'}, optional
        Whether 1-D arrays are returned as MATLAB row or column matrices.
        Default is 'column'.
    
    Returns
    -------
    dims : tuple
        Shape tuple, in the form MATLAB expects it.
    
    Notes
    -----
    We had to decide what shape a 1 dimensional array would be by
    default.  ``np.atleast_2d`` thinks it is a row vector.  The
    default for a vector in MATLAB (e.g. ``>> 1:12``) is a row vector.
    
    Versions of scipy up to and including 0.11 resulted (accidentally)
    in 1-D arrays being read as column vectors.  For the moment, we
    maintain the same tradition here.
    
    Examples
    --------
    >>> matdims(np.array(1)) # numpy scalar
    (1, 1)
    >>> matdims(np.array([1])) # 1d array, 1 element
    (1, 1)
    >>> matdims(np.array([1,2])) # 1d array, 2 elements
    (2, 1)
    >>> matdims(np.array([[2],[3]])) # 2d array, column vector
    (2, 1)
    >>> matdims(np.array([[2,3]])) # 2d array, row vector
    (1, 2)
    >>> matdims(np.array([[[2,3]]])) # 3d array, rowish vector
    (1, 1, 2)
    >>> matdims(np.array([])) # empty 1d array
    (0, 0)
    >>> matdims(np.array([[]])) # empty 2d
    (0, 0)
    >>> matdims(np.array([[[]]])) # empty 3d
    (0, 0, 0)
    
    Optional argument flips 1-D shape behavior.
    
    >>> matdims(np.array([1,2]), 'row') # 1d array, 2 elements
    (1, 2)
    
    The argument has to make sense though
    
    >>> matdims(np.array([1,2]), 'bizarre')
    Traceback (most recent call last):
       ...
    ValueError: 1D option ""bizarre"" is strange
",function,"('arr', 'oned_as')","(nan, 'column')","(nan, 'str')","('arg_info', 'arg_info')","(""(arr, oned_as='column')"",)"
scipy,1.1.0,scipy.io.matlab.mio4.read_dtype,io.matlab.mio4,read_dtype,"Python Library Documentation: function read_dtype in module scipy.io.matlab.miobase

read_dtype(mat_stream, a_dtype)
    Generic get of byte stream data of known type
    
    Parameters
    ----------
    mat_stream : file_like object
        MATLAB (tm) mat file stream
    a_dtype : dtype
        dtype of array to read.  `a_dtype` is assumed to be correct
        endianness.
    
    Returns
    -------
    arr : ndarray
        Array of dtype `a_dtype` read from stream.
",function,"('(mat_stream, a_dtype)',)",scipy,1.1.0,scipy.io.matlab.mio4.read_dtype,io.matlab.mio4,read_dtype,"Python Library Documentation: function read_dtype in module scipy.io.matlab.miobase

read_dtype(mat_stream, a_dtype)
    Generic get of byte stream data of known type
    
    Parameters
    ----------
    mat_stream : file_like object
        MATLAB (tm) mat file stream
    a_dtype : dtype
        dtype of array to read.  `a_dtype` is assumed to be correct
        endianness.
    
    Returns
    -------
    arr : ndarray
        Array of dtype `a_dtype` read from stream.
",function,"('mat_stream', 'a_dtype')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(mat_stream, a_dtype)',)"
scipy,1.1.0,scipy.io.matlab.mio5.BytesIO,io.matlab.mio5,BytesIO,"Python Library Documentation: class BytesIO in module io

class BytesIO(_BufferedIOBase)
 |  Buffered I/O implementation using an in-memory bytes buffer.
 |  
 |  Method resolution order:
 |      BytesIO
 |      _BufferedIOBase
 |      _IOBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __getstate__(...)
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __next__(self, /)
 |      Implement next(self).
 |  
 |  __setstate__(...)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  close(self, /)
 |      Disable all I/O operations.
 |  
 |  flush(self, /)
 |      Does nothing.
 |  
 |  getbuffer(self, /)
 |      Get a read-write view over the contents of the BytesIO object.
 |  
 |  getvalue(self, /)
 |      Retrieve the entire contents of the BytesIO object.
 |  
 |  isatty(self, /)
 |      Always returns False.
 |      
 |      BytesIO objects are not connected to a TTY-like device.
 |  
 |  read(self, size=None, /)
 |      Read at most size bytes, returned as a bytes object.
 |      
 |      If the size argument is negative, read until EOF is reached.
 |      Return an empty bytes object at EOF.
 |  
 |  read1(self, size, /)
 |      Read at most size bytes, returned as a bytes object.
 |      
 |      If the size argument is negative or omitted, read until EOF is reached.
 |      Return an empty bytes object at EOF.
 |  
 |  readable(self, /)
 |      Returns True if the IO object can be read.
 |  
 |  readinto(self, buffer, /)
 |      Read bytes into buffer.
 |      
 |      Returns number of bytes read (0 for EOF), or None if the object
 |      is set not to block and has no data to read.
 |  
 |  readline(self, size=None, /)
 |      Next line from the file, as a bytes object.
 |      
 |      Retain newline.  A non-negative size argument limits the maximum
 |      number of bytes to return (an incomplete line may be returned then).
 |      Return an empty bytes object at EOF.
 |  
 |  readlines(self, size=None, /)
 |      List of bytes objects, each a line from the file.
 |      
 |      Call readline() repeatedly and return a list of the lines so read.
 |      The optional size argument, if given, is an approximate bound on the
 |      total number of bytes in the lines returned.
 |  
 |  seek(self, pos, whence=0, /)
 |      Change stream position.
 |      
 |      Seek to byte offset pos relative to position indicated by whence:
 |           0  Start of stream (the default).  pos should be >= 0;
 |           1  Current position - pos may be negative;
 |           2  End of stream - pos usually negative.
 |      Returns the new absolute position.
 |  
 |  seekable(self, /)
 |      Returns True if the IO object can be seeked.
 |  
 |  tell(self, /)
 |      Current file position, an integer.
 |  
 |  truncate(self, size=None, /)
 |      Truncate the file to at most size bytes.
 |      
 |      Size defaults to the current file position, as returned by tell().
 |      The current file position is unchanged.  Returns the new size.
 |  
 |  writable(self, /)
 |      Returns True if the IO object can be written.
 |  
 |  write(self, b, /)
 |      Write bytes to file.
 |      
 |      Return the number of bytes written.
 |  
 |  writelines(self, lines, /)
 |      Write lines to the file.
 |      
 |      Note that newlines are not added.  lines can be any iterable object
 |      producing bytes-like objects. This is equivalent to calling write() for
 |      each element.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  closed
 |      True if the file is closed.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BufferedIOBase:
 |  
 |  detach(self, /)
 |      Disconnect this buffer from its underlying raw stream and return it.
 |      
 |      After the raw stream has been detached, the buffer is in an unusable
 |      state.
 |  
 |  readinto1(self, buffer, /)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _IOBase:
 |  
 |  __del__(...)
 |  
 |  __enter__(...)
 |  
 |  __exit__(...)
 |  
 |  fileno(self, /)
 |      Returns underlying file descriptor if one exists.
 |      
 |      OSError is raised if the IO object does not use a file descriptor.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _IOBase:
 |  
 |  __dict__
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.matlab.mio5.BytesIO,io.matlab.mio5,BytesIO,"Python Library Documentation: class BytesIO in module io

class BytesIO(_BufferedIOBase)
 |  Buffered I/O implementation using an in-memory bytes buffer.
 |  
 |  Method resolution order:
 |      BytesIO
 |      _BufferedIOBase
 |      _IOBase
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __getstate__(...)
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __next__(self, /)
 |      Implement next(self).
 |  
 |  __setstate__(...)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  close(self, /)
 |      Disable all I/O operations.
 |  
 |  flush(self, /)
 |      Does nothing.
 |  
 |  getbuffer(self, /)
 |      Get a read-write view over the contents of the BytesIO object.
 |  
 |  getvalue(self, /)
 |      Retrieve the entire contents of the BytesIO object.
 |  
 |  isatty(self, /)
 |      Always returns False.
 |      
 |      BytesIO objects are not connected to a TTY-like device.
 |  
 |  read(self, size=None, /)
 |      Read at most size bytes, returned as a bytes object.
 |      
 |      If the size argument is negative, read until EOF is reached.
 |      Return an empty bytes object at EOF.
 |  
 |  read1(self, size, /)
 |      Read at most size bytes, returned as a bytes object.
 |      
 |      If the size argument is negative or omitted, read until EOF is reached.
 |      Return an empty bytes object at EOF.
 |  
 |  readable(self, /)
 |      Returns True if the IO object can be read.
 |  
 |  readinto(self, buffer, /)
 |      Read bytes into buffer.
 |      
 |      Returns number of bytes read (0 for EOF), or None if the object
 |      is set not to block and has no data to read.
 |  
 |  readline(self, size=None, /)
 |      Next line from the file, as a bytes object.
 |      
 |      Retain newline.  A non-negative size argument limits the maximum
 |      number of bytes to return (an incomplete line may be returned then).
 |      Return an empty bytes object at EOF.
 |  
 |  readlines(self, size=None, /)
 |      List of bytes objects, each a line from the file.
 |      
 |      Call readline() repeatedly and return a list of the lines so read.
 |      The optional size argument, if given, is an approximate bound on the
 |      total number of bytes in the lines returned.
 |  
 |  seek(self, pos, whence=0, /)
 |      Change stream position.
 |      
 |      Seek to byte offset pos relative to position indicated by whence:
 |           0  Start of stream (the default).  pos should be >= 0;
 |           1  Current position - pos may be negative;
 |           2  End of stream - pos usually negative.
 |      Returns the new absolute position.
 |  
 |  seekable(self, /)
 |      Returns True if the IO object can be seeked.
 |  
 |  tell(self, /)
 |      Current file position, an integer.
 |  
 |  truncate(self, size=None, /)
 |      Truncate the file to at most size bytes.
 |      
 |      Size defaults to the current file position, as returned by tell().
 |      The current file position is unchanged.  Returns the new size.
 |  
 |  writable(self, /)
 |      Returns True if the IO object can be written.
 |  
 |  write(self, b, /)
 |      Write bytes to file.
 |      
 |      Return the number of bytes written.
 |  
 |  writelines(self, lines, /)
 |      Write lines to the file.
 |      
 |      Note that newlines are not added.  lines can be any iterable object
 |      producing bytes-like objects. This is equivalent to calling write() for
 |      each element.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  closed
 |      True if the file is closed.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BufferedIOBase:
 |  
 |  detach(self, /)
 |      Disconnect this buffer from its underlying raw stream and return it.
 |      
 |      After the raw stream has been detached, the buffer is in an unusable
 |      state.
 |  
 |  readinto1(self, buffer, /)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _IOBase:
 |  
 |  __del__(...)
 |  
 |  __enter__(...)
 |  
 |  __exit__(...)
 |  
 |  fileno(self, /)
 |      Returns underlying file descriptor if one exists.
 |      
 |      OSError is raised if the IO object does not use a file descriptor.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _IOBase:
 |  
 |  __dict__
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.matlab.mio5.EmptyStructMarker,io.matlab.mio5,EmptyStructMarker,"Python Library Documentation: class EmptyStructMarker in module scipy.io.matlab.mio5

class EmptyStructMarker(builtins.object)
 |  Class to indicate presence of empty matlab struct on output
 |  
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.matlab.mio5.EmptyStructMarker,io.matlab.mio5,EmptyStructMarker,"Python Library Documentation: class EmptyStructMarker in module scipy.io.matlab.mio5

class EmptyStructMarker(builtins.object)
 |  Class to indicate presence of empty matlab struct on output
 |  
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.matlab.mio5.MatFile5Reader,io.matlab.mio5,MatFile5Reader,"Python Library Documentation: class MatFile5Reader in module scipy.io.matlab.mio5

class MatFile5Reader(scipy.io.matlab.miobase.MatFileReader)
 |  Reader for Mat 5 mat files
 |  Adds the following attribute to base class
 |  
 |  uint16_codec - char codec to use for uint16 char arrays
 |      (defaults to system default codec)
 |  
 |  Uses variable reader that has the following stardard interface (see
 |  abstract class in ``miobase``::
 |  
 |     __init__(self, file_reader)
 |     read_header(self)
 |     array_from_header(self)
 |  
 |  and added interface::
 |  
 |     set_stream(self, stream)
 |     read_full_tag(self)
 |  
 |  Method resolution order:
 |      MatFile5Reader
 |      scipy.io.matlab.miobase.MatFileReader
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, mat_stream, byte_order=None, mat_dtype=False, squeeze_me=False, chars_as_strings=True, matlab_compatible=False, struct_as_record=True, verify_compressed_data_integrity=True, uint16_codec=None)
 |      Initializer for matlab 5 file format reader
 |      
 |      mat_stream : file-like
 |         Object with file API, open for reading.
 |      byte_order : str or None, optional
 |         None by default, implying byte order guessed from mat
 |         file. Otherwise can be one of ('native', '=', 'little', '<',
 |         'BIG', '>').
 |      mat_dtype : bool, optional
 |         If True, return arrays in same dtype as would be loaded into
 |         MATLAB (instead of the dtype with which they are saved).
 |      squeeze_me : bool, optional
 |         Whether to squeeze unit matrix dimensions or not.
 |      chars_as_strings : bool, optional
 |         Whether to convert char arrays to string arrays.
 |      matlab_compatible : bool, optional
 |         Returns matrices as would be loaded by MATLAB (implies
 |         squeeze_me=False, chars_as_strings=False, mat_dtype=True,
 |         struct_as_record=True).
 |      struct_as_record : bool, optional
 |         Whether to load MATLAB structs as numpy record arrays, or as
 |         old-style numpy arrays with dtype=object.  Setting this flag to
 |         False replicates the behavior of scipy version 0.7.x (returning
 |         numpy object arrays).  The default setting is True, because it
 |         allows easier round-trip load and save of MATLAB files.
 |      uint16_codec : {None, string}
 |          Set codec to use for uint16 char arrays (e.g. 'utf-8').
 |          Use system default codec if None
 |  
 |  get_variables(self, variable_names=None)
 |      get variables from stream as dictionary
 |      
 |      variable_names   - optional list of variable names to get
 |      
 |      If variable_names is None, then get all variables in file
 |  
 |  guess_byte_order(self)
 |      Guess byte order.
 |      Sets stream pointer to 0
 |  
 |  initialize_read(self)
 |      Run when beginning read of variables
 |      
 |      Sets up readers from parameters in `self`
 |  
 |  list_variables(self)
 |      list variables from stream
 |  
 |  read_file_header(self)
 |      Read in mat 5 file header
 |  
 |  read_var_array(self, header, process=True)
 |      Read array, given `header`
 |      
 |      Parameters
 |      ----------
 |      header : header object
 |         object with fields defining variable header
 |      process : {True, False} bool, optional
 |         If True, apply recursive post-processing during loading of
 |         array.
 |      
 |      Returns
 |      -------
 |      arr : array
 |         array with post-processing applied or not according to
 |         `process`.
 |  
 |  read_var_header(self)
 |      Read header, return header, next position
 |      
 |      Header has to define at least .name and .is_global
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      header : object
 |         object that can be passed to self.read_var_array, and that
 |         has attributes .name and .is_global
 |      next_position : int
 |         position in stream of next variable
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.io.matlab.miobase.MatFileReader:
 |  
 |  end_of_stream(self)
 |  
 |  set_matlab_compatible(self)
 |      Sets options to return arrays as MATLAB loads them
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.io.matlab.miobase.MatFileReader:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, mat_stream, byte_order=None, mat_dtype=False, squeeze_me=False, chars_as_strings=True, matlab_compatible=False, struct_as_record=True, verify_compressed_data_integrity=True, uint16_codec=None)',)",scipy,1.1.0,scipy.io.matlab.mio5.MatFile5Reader,io.matlab.mio5,MatFile5Reader,"Python Library Documentation: class MatFile5Reader in module scipy.io.matlab.mio5

class MatFile5Reader(scipy.io.matlab.miobase.MatFileReader)
 |  Reader for Mat 5 mat files
 |  Adds the following attribute to base class
 |  
 |  uint16_codec - char codec to use for uint16 char arrays
 |      (defaults to system default codec)
 |  
 |  Uses variable reader that has the following stardard interface (see
 |  abstract class in ``miobase``::
 |  
 |     __init__(self, file_reader)
 |     read_header(self)
 |     array_from_header(self)
 |  
 |  and added interface::
 |  
 |     set_stream(self, stream)
 |     read_full_tag(self)
 |  
 |  Method resolution order:
 |      MatFile5Reader
 |      scipy.io.matlab.miobase.MatFileReader
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, mat_stream, byte_order=None, mat_dtype=False, squeeze_me=False, chars_as_strings=True, matlab_compatible=False, struct_as_record=True, verify_compressed_data_integrity=True, uint16_codec=None)
 |      Initializer for matlab 5 file format reader
 |      
 |      mat_stream : file-like
 |         Object with file API, open for reading.
 |      byte_order : str or None, optional
 |         None by default, implying byte order guessed from mat
 |         file. Otherwise can be one of ('native', '=', 'little', '<',
 |         'BIG', '>').
 |      mat_dtype : bool, optional
 |         If True, return arrays in same dtype as would be loaded into
 |         MATLAB (instead of the dtype with which they are saved).
 |      squeeze_me : bool, optional
 |         Whether to squeeze unit matrix dimensions or not.
 |      chars_as_strings : bool, optional
 |         Whether to convert char arrays to string arrays.
 |      matlab_compatible : bool, optional
 |         Returns matrices as would be loaded by MATLAB (implies
 |         squeeze_me=False, chars_as_strings=False, mat_dtype=True,
 |         struct_as_record=True).
 |      struct_as_record : bool, optional
 |         Whether to load MATLAB structs as numpy record arrays, or as
 |         old-style numpy arrays with dtype=object.  Setting this flag to
 |         False replicates the behavior of scipy version 0.7.x (returning
 |         numpy object arrays).  The default setting is True, because it
 |         allows easier round-trip load and save of MATLAB files.
 |      uint16_codec : {None, string}
 |          Set codec to use for uint16 char arrays (e.g. 'utf-8').
 |          Use system default codec if None
 |  
 |  get_variables(self, variable_names=None)
 |      get variables from stream as dictionary
 |      
 |      variable_names   - optional list of variable names to get
 |      
 |      If variable_names is None, then get all variables in file
 |  
 |  guess_byte_order(self)
 |      Guess byte order.
 |      Sets stream pointer to 0
 |  
 |  initialize_read(self)
 |      Run when beginning read of variables
 |      
 |      Sets up readers from parameters in `self`
 |  
 |  list_variables(self)
 |      list variables from stream
 |  
 |  read_file_header(self)
 |      Read in mat 5 file header
 |  
 |  read_var_array(self, header, process=True)
 |      Read array, given `header`
 |      
 |      Parameters
 |      ----------
 |      header : header object
 |         object with fields defining variable header
 |      process : {True, False} bool, optional
 |         If True, apply recursive post-processing during loading of
 |         array.
 |      
 |      Returns
 |      -------
 |      arr : array
 |         array with post-processing applied or not according to
 |         `process`.
 |  
 |  read_var_header(self)
 |      Read header, return header, next position
 |      
 |      Header has to define at least .name and .is_global
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      header : object
 |         object that can be passed to self.read_var_array, and that
 |         has attributes .name and .is_global
 |      next_position : int
 |         position in stream of next variable
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.io.matlab.miobase.MatFileReader:
 |  
 |  end_of_stream(self)
 |  
 |  set_matlab_compatible(self)
 |      Sets options to return arrays as MATLAB loads them
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.io.matlab.miobase.MatFileReader:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'mat_stream', 'byte_order', 'mat_dtype', 'squeeze_me', 'chars_as_strings', 'matlab_compatible', 'struct_as_record', 'verify_compressed_data_integrity', 'uint16_codec')","(nan, nan, None, False, False, True, False, True, True, None)","(nan, nan, 'NoneType', 'bool', 'bool', 'bool', 'bool', 'bool', 'bool', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, mat_stream, byte_order=None, mat_dtype=False, squeeze_me=False, chars_as_strings=True, matlab_compatible=False, struct_as_record=True, verify_compressed_data_integrity=True, uint16_codec=None)',)"
scipy,1.1.0,scipy.io.matlab.mio5.MatFile5Writer,io.matlab.mio5,MatFile5Writer,"Python Library Documentation: class MatFile5Writer in module scipy.io.matlab.mio5

class MatFile5Writer(builtins.object)
 |  Class for writing mat5 files
 |  
 |  Methods defined here:
 |  
 |  __init__(self, file_stream, do_compression=False, unicode_strings=False, global_vars=None, long_field_names=False, oned_as='row')
 |      Initialize writer for matlab 5 format files
 |      
 |      Parameters
 |      ----------
 |      do_compression : bool, optional
 |         Whether to compress matrices on write. Default is False.
 |      unicode_strings : bool, optional
 |         If True, write strings as Unicode, else MATLAB usual encoding.
 |      global_vars : None or sequence of strings, optional
 |          Names of variables to be marked as global for matlab
 |      long_field_names : bool, optional
 |         * False - maximum field name length in a structure is 31 characters
 |           which is the documented maximum length. This is the default.
 |         * True - maximum field name length in a structure is 63 characters
 |           which works for MATLAB 7.6
 |      oned_as : {'row', 'column'}, optional
 |         If 'column', write 1-D numpy arrays as column vectors.
 |         If 'row', write 1D numpy arrays as row vectors.
 |  
 |  put_variables(self, mdict, write_header=None)
 |      Write variables in `mdict` to stream
 |      
 |      Parameters
 |      ----------
 |      mdict : mapping
 |         mapping with method ``items`` returns name, contents pairs where
 |         ``name`` which will appear in the matlab workspace in file load, and
 |         ``contents`` is something writeable to a matlab file, such as a numpy
 |         array.
 |      write_header : {None, True, False}, optional
 |         If True, then write the matlab file header before writing the
 |         variables.  If None (the default) then write the file header
 |         if we are at position 0 in the stream.  By setting False
 |         here, and setting the stream position to the end of the file,
 |         you can append variables to a matlab file
 |  
 |  write_file_header(self)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"(""(self, file_stream, do_compression=False, unicode_strings=False, global_vars=None, long_field_names=False, oned_as='row')"",)",scipy,1.1.0,scipy.io.matlab.mio5.MatFile5Writer,io.matlab.mio5,MatFile5Writer,"Python Library Documentation: class MatFile5Writer in module scipy.io.matlab.mio5

class MatFile5Writer(builtins.object)
 |  Class for writing mat5 files
 |  
 |  Methods defined here:
 |  
 |  __init__(self, file_stream, do_compression=False, unicode_strings=False, global_vars=None, long_field_names=False, oned_as='row')
 |      Initialize writer for matlab 5 format files
 |      
 |      Parameters
 |      ----------
 |      do_compression : bool, optional
 |         Whether to compress matrices on write. Default is False.
 |      unicode_strings : bool, optional
 |         If True, write strings as Unicode, else MATLAB usual encoding.
 |      global_vars : None or sequence of strings, optional
 |          Names of variables to be marked as global for matlab
 |      long_field_names : bool, optional
 |         * False - maximum field name length in a structure is 31 characters
 |           which is the documented maximum length. This is the default.
 |         * True - maximum field name length in a structure is 63 characters
 |           which works for MATLAB 7.6
 |      oned_as : {'row', 'column'}, optional
 |         If 'column', write 1-D numpy arrays as column vectors.
 |         If 'row', write 1D numpy arrays as row vectors.
 |  
 |  put_variables(self, mdict, write_header=None)
 |      Write variables in `mdict` to stream
 |      
 |      Parameters
 |      ----------
 |      mdict : mapping
 |         mapping with method ``items`` returns name, contents pairs where
 |         ``name`` which will appear in the matlab workspace in file load, and
 |         ``contents`` is something writeable to a matlab file, such as a numpy
 |         array.
 |      write_header : {None, True, False}, optional
 |         If True, then write the matlab file header before writing the
 |         variables.  If None (the default) then write the file header
 |         if we are at position 0 in the stream.  By setting False
 |         here, and setting the stream position to the end of the file,
 |         you can append variables to a matlab file
 |  
 |  write_file_header(self)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'file_stream', 'do_compression', 'unicode_strings', 'global_vars', 'long_field_names', 'oned_as')","(nan, nan, False, False, None, False, 'row')","(nan, nan, 'bool', 'bool', 'NoneType', 'bool', 'str')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(self, file_stream, do_compression=False, unicode_strings=False, global_vars=None, long_field_names=False, oned_as='row')"",)"
scipy,1.1.0,scipy.io.matlab.mio5.MatFileReader,io.matlab.mio5,MatFileReader,"Python Library Documentation: class MatFileReader in module scipy.io.matlab.miobase

class MatFileReader(builtins.object)
 |  Base object for reading mat files
 |  
 |  To make this class functional, you will need to override the
 |  following methods:
 |  
 |  matrix_getter_factory   - gives object to fetch next matrix from stream
 |  guess_byte_order        - guesses file byte order from file
 |  
 |  Methods defined here:
 |  
 |  __init__(self, mat_stream, byte_order=None, mat_dtype=False, squeeze_me=False, chars_as_strings=True, matlab_compatible=False, struct_as_record=True, verify_compressed_data_integrity=True)
 |          Initializer for mat file reader
 |      
 |          mat_stream : file-like
 |              object with file API, open for reading
 |      byte_order : str or None, optional
 |         None by default, implying byte order guessed from mat
 |         file. Otherwise can be one of ('native', '=', 'little', '<',
 |         'BIG', '>').
 |      mat_dtype : bool, optional
 |         If True, return arrays in same dtype as would be loaded into
 |         MATLAB (instead of the dtype with which they are saved).
 |      squeeze_me : bool, optional
 |         Whether to squeeze unit matrix dimensions or not.
 |      chars_as_strings : bool, optional
 |         Whether to convert char arrays to string arrays.
 |      matlab_compatible : bool, optional
 |         Returns matrices as would be loaded by MATLAB (implies
 |         squeeze_me=False, chars_as_strings=False, mat_dtype=True,
 |         struct_as_record=True).
 |  
 |  end_of_stream(self)
 |  
 |  guess_byte_order(self)
 |      As we do not know what file type we have, assume native
 |  
 |  set_matlab_compatible(self)
 |      Sets options to return arrays as MATLAB loads them
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, mat_stream, byte_order=None, mat_dtype=False, squeeze_me=False, chars_as_strings=True, matlab_compatible=False, struct_as_record=True, verify_compressed_data_integrity=True)',)",scipy,1.1.0,scipy.io.matlab.mio5.MatFileReader,io.matlab.mio5,MatFileReader,"Python Library Documentation: class MatFileReader in module scipy.io.matlab.miobase

class MatFileReader(builtins.object)
 |  Base object for reading mat files
 |  
 |  To make this class functional, you will need to override the
 |  following methods:
 |  
 |  matrix_getter_factory   - gives object to fetch next matrix from stream
 |  guess_byte_order        - guesses file byte order from file
 |  
 |  Methods defined here:
 |  
 |  __init__(self, mat_stream, byte_order=None, mat_dtype=False, squeeze_me=False, chars_as_strings=True, matlab_compatible=False, struct_as_record=True, verify_compressed_data_integrity=True)
 |          Initializer for mat file reader
 |      
 |          mat_stream : file-like
 |              object with file API, open for reading
 |      byte_order : str or None, optional
 |         None by default, implying byte order guessed from mat
 |         file. Otherwise can be one of ('native', '=', 'little', '<',
 |         'BIG', '>').
 |      mat_dtype : bool, optional
 |         If True, return arrays in same dtype as would be loaded into
 |         MATLAB (instead of the dtype with which they are saved).
 |      squeeze_me : bool, optional
 |         Whether to squeeze unit matrix dimensions or not.
 |      chars_as_strings : bool, optional
 |         Whether to convert char arrays to string arrays.
 |      matlab_compatible : bool, optional
 |         Returns matrices as would be loaded by MATLAB (implies
 |         squeeze_me=False, chars_as_strings=False, mat_dtype=True,
 |         struct_as_record=True).
 |  
 |  end_of_stream(self)
 |  
 |  guess_byte_order(self)
 |      As we do not know what file type we have, assume native
 |  
 |  set_matlab_compatible(self)
 |      Sets options to return arrays as MATLAB loads them
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'mat_stream', 'byte_order', 'mat_dtype', 'squeeze_me', 'chars_as_strings', 'matlab_compatible', 'struct_as_record', 'verify_compressed_data_integrity')","(nan, nan, None, False, False, True, False, True, True)","(nan, nan, 'NoneType', 'bool', 'bool', 'bool', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, mat_stream, byte_order=None, mat_dtype=False, squeeze_me=False, chars_as_strings=True, matlab_compatible=False, struct_as_record=True, verify_compressed_data_integrity=True)',)"
scipy,1.1.0,scipy.io.matlab.mio5.MatReadError,io.matlab.mio5,MatReadError,"Python Library Documentation: class MatReadError in module scipy.io.matlab.miobase

class MatReadError(builtins.Exception)
 |  Common base class for all non-exit exceptions.
 |  
 |  Method resolution order:
 |      MatReadError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.matlab.mio5.MatReadError,io.matlab.mio5,MatReadError,"Python Library Documentation: class MatReadError in module scipy.io.matlab.miobase

class MatReadError(builtins.Exception)
 |  Common base class for all non-exit exceptions.
 |  
 |  Method resolution order:
 |      MatReadError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.matlab.mio5.MatReadWarning,io.matlab.mio5,MatReadWarning,"Python Library Documentation: class MatReadWarning in module scipy.io.matlab.miobase

class MatReadWarning(builtins.UserWarning)
 |  Base class for warnings generated by user code.
 |  
 |  Method resolution order:
 |      MatReadWarning
 |      builtins.UserWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.UserWarning:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.matlab.mio5.MatReadWarning,io.matlab.mio5,MatReadWarning,"Python Library Documentation: class MatReadWarning in module scipy.io.matlab.miobase

class MatReadWarning(builtins.UserWarning)
 |  Base class for warnings generated by user code.
 |  
 |  Method resolution order:
 |      MatReadWarning
 |      builtins.UserWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.UserWarning:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.matlab.mio5.MatWriteError,io.matlab.mio5,MatWriteError,"Python Library Documentation: class MatWriteError in module scipy.io.matlab.miobase

class MatWriteError(builtins.Exception)
 |  Common base class for all non-exit exceptions.
 |  
 |  Method resolution order:
 |      MatWriteError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.matlab.mio5.MatWriteError,io.matlab.mio5,MatWriteError,"Python Library Documentation: class MatWriteError in module scipy.io.matlab.miobase

class MatWriteError(builtins.Exception)
 |  Common base class for all non-exit exceptions.
 |  
 |  Method resolution order:
 |      MatWriteError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.matlab.mio5.MatlabFunction,io.matlab.mio5,MatlabFunction,"Python Library Documentation: class MatlabFunction in module scipy.io.matlab.mio5_params

class MatlabFunction(numpy.ndarray)
 |  Subclass to signal this is a matlab function
 |  
 |  Method resolution order:
 |      MatlabFunction
 |      numpy.ndarray
 |      builtins.object
 |  
 |  Static methods defined here:
 |  
 |  __new__(cls, input_array)
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from numpy.ndarray:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __array__(...)
 |      a.__array__(|dtype) -> reference if type unchanged, copy otherwise.
 |      
 |      Returns either a new reference to self if dtype is not given or a new array
 |      of provided data type if dtype is different from the current dtype of the
 |      array.
 |  
 |  __array_prepare__(...)
 |      a.__array_prepare__(obj) -> Object of same type as ndarray object obj.
 |  
 |  __array_ufunc__(...)
 |  
 |  __array_wrap__(...)
 |      a.__array_wrap__(obj) -> Object of same type as ndarray object a.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __complex__(...)
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __copy__(...)
 |      a.__copy__()
 |      
 |      Used if :func:`copy.copy` is called on an array. Returns a copy of the array.
 |      
 |      Equivalent to ``a.copy(order='K')``.
 |  
 |  __deepcopy__(...)
 |      a.__deepcopy__(memo, /) -> Deep copy of array.
 |      
 |      Used if :func:`copy.deepcopy` is called on an array.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __format__(...)
 |      default object formatter
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iadd__(self, value, /)
 |      Return self+=value.
 |  
 |  __iand__(self, value, /)
 |      Return self&=value.
 |  
 |  __ifloordiv__(self, value, /)
 |      Return self//=value.
 |  
 |  __ilshift__(self, value, /)
 |      Return self<<=value.
 |  
 |  __imatmul__(self, value, /)
 |      Return self@=value.
 |  
 |  __imod__(self, value, /)
 |      Return self%=value.
 |  
 |  __imul__(self, value, /)
 |      Return self*=value.
 |  
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __ior__(self, value, /)
 |      Return self|=value.
 |  
 |  __ipow__(self, value, /)
 |      Return self**=value.
 |  
 |  __irshift__(self, value, /)
 |      Return self>>=value.
 |  
 |  __isub__(self, value, /)
 |      Return self-=value.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __itruediv__(self, value, /)
 |      Return self/=value.
 |  
 |  __ixor__(self, value, /)
 |      Return self^=value.
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __matmul__(self, value, /)
 |      Return self@value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __reduce__(...)
 |      a.__reduce__()
 |      
 |      For pickling.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmatmul__(self, value, /)
 |      Return value@self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __setstate__(...)
 |      a.__setstate__(state, /)
 |      
 |      For unpickling.
 |      
 |      The `state` argument must be a sequence that contains the following
 |      elements:
 |      
 |      Parameters
 |      ----------
 |      version : int
 |          optional pickle version. If omitted defaults to 0.
 |      shape : tuple
 |      dtype : data-type
 |      isFortran : bool
 |      rawdata : string or list
 |          a binary string with the data (or a list if 'a' is an object array)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  all(...)
 |      a.all(axis=None, out=None, keepdims=False)
 |      
 |      Returns True if all elements evaluate to True.
 |      
 |      Refer to `numpy.all` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.all : equivalent function
 |  
 |  any(...)
 |      a.any(axis=None, out=None, keepdims=False)
 |      
 |      Returns True if any of the elements of `a` evaluate to True.
 |      
 |      Refer to `numpy.any` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.any : equivalent function
 |  
 |  argmax(...)
 |      a.argmax(axis=None, out=None)
 |      
 |      Return indices of the maximum values along the given axis.
 |      
 |      Refer to `numpy.argmax` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argmax : equivalent function
 |  
 |  argmin(...)
 |      a.argmin(axis=None, out=None)
 |      
 |      Return indices of the minimum values along the given axis of `a`.
 |      
 |      Refer to `numpy.argmin` for detailed documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argmin : equivalent function
 |  
 |  argpartition(...)
 |      a.argpartition(kth, axis=-1, kind='introselect', order=None)
 |      
 |      Returns the indices that would partition this array.
 |      
 |      Refer to `numpy.argpartition` for full documentation.
 |      
 |      .. versionadded:: 1.8.0
 |      
 |      See Also
 |      --------
 |      numpy.argpartition : equivalent function
 |  
 |  argsort(...)
 |      a.argsort(axis=-1, kind='quicksort', order=None)
 |      
 |      Returns the indices that would sort this array.
 |      
 |      Refer to `numpy.argsort` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argsort : equivalent function
 |  
 |  astype(...)
 |      a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)
 |      
 |      Copy of the array, cast to a specified type.
 |      
 |      Parameters
 |      ----------
 |      dtype : str or dtype
 |          Typecode or data-type to which the array is cast.
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          Controls the memory layout order of the result.
 |          'C' means C order, 'F' means Fortran order, 'A'
 |          means 'F' order if all the arrays are Fortran contiguous,
 |          'C' order otherwise, and 'K' means as close to the
 |          order the array elements appear in memory as possible.
 |          Default is 'K'.
 |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
 |          Controls what kind of data casting may occur. Defaults to 'unsafe'
 |          for backwards compatibility.
 |      
 |            * 'no' means the data types should not be cast at all.
 |            * 'equiv' means only byte-order changes are allowed.
 |            * 'safe' means only casts which can preserve values are allowed.
 |            * 'same_kind' means only safe casts or casts within a kind,
 |              like float64 to float32, are allowed.
 |            * 'unsafe' means any data conversions may be done.
 |      subok : bool, optional
 |          If True, then sub-classes will be passed-through (default), otherwise
 |          the returned array will be forced to be a base-class array.
 |      copy : bool, optional
 |          By default, astype always returns a newly allocated array. If this
 |          is set to false, and the `dtype`, `order`, and `subok`
 |          requirements are satisfied, the input array is returned instead
 |          of a copy.
 |      
 |      Returns
 |      -------
 |      arr_t : ndarray
 |          Unless `copy` is False and the other conditions for returning the input
 |          array are satisfied (see description for `copy` input parameter), `arr_t`
 |          is a new array of the same shape as the input array, with dtype, order
 |          given by `dtype`, `order`.
 |      
 |      Notes
 |      -----
 |      Starting in NumPy 1.9, astype method now returns an error if the string
 |      dtype to cast to is not long enough in 'safe' casting mode to hold the max
 |      value of integer/float array that is being casted. Previously the casting
 |      was allowed even if the result was truncated.
 |      
 |      Raises
 |      ------
 |      ComplexWarning
 |          When casting from complex to float or int. To avoid this,
 |          one should use ``a.real.astype(t)``.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 2.5])
 |      >>> x
 |      array([ 1. ,  2. ,  2.5])
 |      
 |      >>> x.astype(int)
 |      array([1, 2, 2])
 |  
 |  byteswap(...)
 |      a.byteswap(inplace=False)
 |      
 |      Swap the bytes of the array elements
 |      
 |      Toggle between low-endian and big-endian data representation by
 |      returning a byteswapped array, optionally swapped in-place.
 |      
 |      Parameters
 |      ----------
 |      inplace : bool, optional
 |          If ``True``, swap bytes in-place, default is ``False``.
 |      
 |      Returns
 |      -------
 |      out : ndarray
 |          The byteswapped array. If `inplace` is ``True``, this is
 |          a view to self.
 |      
 |      Examples
 |      --------
 |      >>> A = np.array([1, 256, 8755], dtype=np.int16)
 |      >>> map(hex, A)
 |      ['0x1', '0x100', '0x2233']
 |      >>> A.byteswap(inplace=True)
 |      array([  256,     1, 13090], dtype=int16)
 |      >>> map(hex, A)
 |      ['0x100', '0x1', '0x3322']
 |      
 |      Arrays of strings are not swapped
 |      
 |      >>> A = np.array(['ceg', 'fac'])
 |      >>> A.byteswap()
 |      array(['ceg', 'fac'],
 |            dtype='|S3')
 |  
 |  choose(...)
 |      a.choose(choices, out=None, mode='raise')
 |      
 |      Use an index array to construct a new array from a set of choices.
 |      
 |      Refer to `numpy.choose` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.choose : equivalent function
 |  
 |  clip(...)
 |      a.clip(min=None, max=None, out=None)
 |      
 |      Return an array whose values are limited to ``[min, max]``.
 |      One of max or min must be given.
 |      
 |      Refer to `numpy.clip` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.clip : equivalent function
 |  
 |  compress(...)
 |      a.compress(condition, axis=None, out=None)
 |      
 |      Return selected slices of this array along given axis.
 |      
 |      Refer to `numpy.compress` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.compress : equivalent function
 |  
 |  conj(...)
 |      a.conj()
 |      
 |      Complex-conjugate all elements.
 |      
 |      Refer to `numpy.conjugate` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.conjugate : equivalent function
 |  
 |  conjugate(...)
 |      a.conjugate()
 |      
 |      Return the complex conjugate, element-wise.
 |      
 |      Refer to `numpy.conjugate` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.conjugate : equivalent function
 |  
 |  copy(...)
 |      a.copy(order='C')
 |      
 |      Return a copy of the array.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          Controls the memory layout of the copy. 'C' means C-order,
 |          'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
 |          'C' otherwise. 'K' means match the layout of `a` as closely
 |          as possible. (Note that this function and :func:`numpy.copy` are very
 |          similar, but have different default values for their order=
 |          arguments.)
 |      
 |      See also
 |      --------
 |      numpy.copy
 |      numpy.copyto
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[1,2,3],[4,5,6]], order='F')
 |      
 |      >>> y = x.copy()
 |      
 |      >>> x.fill(0)
 |      
 |      >>> x
 |      array([[0, 0, 0],
 |             [0, 0, 0]])
 |      
 |      >>> y
 |      array([[1, 2, 3],
 |             [4, 5, 6]])
 |      
 |      >>> y.flags['C_CONTIGUOUS']
 |      True
 |  
 |  cumprod(...)
 |      a.cumprod(axis=None, dtype=None, out=None)
 |      
 |      Return the cumulative product of the elements along the given axis.
 |      
 |      Refer to `numpy.cumprod` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.cumprod : equivalent function
 |  
 |  cumsum(...)
 |      a.cumsum(axis=None, dtype=None, out=None)
 |      
 |      Return the cumulative sum of the elements along the given axis.
 |      
 |      Refer to `numpy.cumsum` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.cumsum : equivalent function
 |  
 |  diagonal(...)
 |      a.diagonal(offset=0, axis1=0, axis2=1)
 |      
 |      Return specified diagonals. In NumPy 1.9 the returned array is a
 |      read-only view instead of a copy as in previous NumPy versions.  In
 |      a future version the read-only restriction will be removed.
 |      
 |      Refer to :func:`numpy.diagonal` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.diagonal : equivalent function
 |  
 |  dot(...)
 |      a.dot(b, out=None)
 |      
 |      Dot product of two arrays.
 |      
 |      Refer to `numpy.dot` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.dot : equivalent function
 |      
 |      Examples
 |      --------
 |      >>> a = np.eye(2)
 |      >>> b = np.ones((2, 2)) * 2
 |      >>> a.dot(b)
 |      array([[ 2.,  2.],
 |             [ 2.,  2.]])
 |      
 |      This array method can be conveniently chained:
 |      
 |      >>> a.dot(b).dot(b)
 |      array([[ 8.,  8.],
 |             [ 8.,  8.]])
 |  
 |  dump(...)
 |      a.dump(file)
 |      
 |      Dump a pickle of the array to the specified file.
 |      The array can be read back with pickle.load or numpy.load.
 |      
 |      Parameters
 |      ----------
 |      file : str
 |          A string naming the dump file.
 |  
 |  dumps(...)
 |      a.dumps()
 |      
 |      Returns the pickle of the array as a string.
 |      pickle.loads or numpy.loads will convert the string back to an array.
 |      
 |      Parameters
 |      ----------
 |      None
 |  
 |  fill(...)
 |      a.fill(value)
 |      
 |      Fill the array with a scalar value.
 |      
 |      Parameters
 |      ----------
 |      value : scalar
 |          All elements of `a` will be assigned this value.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([1, 2])
 |      >>> a.fill(0)
 |      >>> a
 |      array([0, 0])
 |      >>> a = np.empty(2)
 |      >>> a.fill(1)
 |      >>> a
 |      array([ 1.,  1.])
 |  
 |  flatten(...)
 |      a.flatten(order='C')
 |      
 |      Return a copy of the array collapsed into one dimension.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          'C' means to flatten in row-major (C-style) order.
 |          'F' means to flatten in column-major (Fortran-
 |          style) order. 'A' means to flatten in column-major
 |          order if `a` is Fortran *contiguous* in memory,
 |          row-major order otherwise. 'K' means to flatten
 |          `a` in the order the elements occur in memory.
 |          The default is 'C'.
 |      
 |      Returns
 |      -------
 |      y : ndarray
 |          A copy of the input array, flattened to one dimension.
 |      
 |      See Also
 |      --------
 |      ravel : Return a flattened array.
 |      flat : A 1-D flat iterator over the array.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1,2], [3,4]])
 |      >>> a.flatten()
 |      array([1, 2, 3, 4])
 |      >>> a.flatten('F')
 |      array([1, 3, 2, 4])
 |  
 |  getfield(...)
 |      a.getfield(dtype, offset=0)
 |      
 |      Returns a field of the given array as a certain type.
 |      
 |      A field is a view of the array data with a given data-type. The values in
 |      the view are determined by the given type and the offset into the current
 |      array in bytes. The offset needs to be such that the view dtype fits in the
 |      array dtype; for example an array of dtype complex128 has 16-byte elements.
 |      If taking a view with a 32-bit integer (4 bytes), the offset needs to be
 |      between 0 and 12 bytes.
 |      
 |      Parameters
 |      ----------
 |      dtype : str or dtype
 |          The data type of the view. The dtype size of the view can not be larger
 |          than that of the array itself.
 |      offset : int
 |          Number of bytes to skip before beginning the element view.
 |      
 |      Examples
 |      --------
 |      >>> x = np.diag([1.+1.j]*2)
 |      >>> x[1, 1] = 2 + 4.j
 |      >>> x
 |      array([[ 1.+1.j,  0.+0.j],
 |             [ 0.+0.j,  2.+4.j]])
 |      >>> x.getfield(np.float64)
 |      array([[ 1.,  0.],
 |             [ 0.,  2.]])
 |      
 |      By choosing an offset of 8 bytes we can select the complex part of the
 |      array for our view:
 |      
 |      >>> x.getfield(np.float64, offset=8)
 |      array([[ 1.,  0.],
 |         [ 0.,  4.]])
 |  
 |  item(...)
 |      a.item(*args)
 |      
 |      Copy an element of an array to a standard Python scalar and return it.
 |      
 |      Parameters
 |      ----------
 |      \*args : Arguments (variable number and type)
 |      
 |          * none: in this case, the method only works for arrays
 |            with one element (`a.size == 1`), which element is
 |            copied into a standard Python scalar object and returned.
 |      
 |          * int_type: this argument is interpreted as a flat index into
 |            the array, specifying which element to copy and return.
 |      
 |          * tuple of int_types: functions as does a single int_type argument,
 |            except that the argument is interpreted as an nd-index into the
 |            array.
 |      
 |      Returns
 |      -------
 |      z : Standard Python scalar object
 |          A copy of the specified element of the array as a suitable
 |          Python scalar
 |      
 |      Notes
 |      -----
 |      When the data type of `a` is longdouble or clongdouble, item() returns
 |      a scalar array object because there is no available Python scalar that
 |      would not lose information. Void arrays return a buffer object for item(),
 |      unless fields are defined, in which case a tuple is returned.
 |      
 |      `item` is very similar to a[args], except, instead of an array scalar,
 |      a standard Python scalar is returned. This can be useful for speeding up
 |      access to elements of the array and doing arithmetic on elements of the
 |      array using Python's optimized math.
 |      
 |      Examples
 |      --------
 |      >>> x = np.random.randint(9, size=(3, 3))
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 8, 3],
 |             [8, 5, 3]])
 |      >>> x.item(3)
 |      2
 |      >>> x.item(7)
 |      5
 |      >>> x.item((0, 1))
 |      1
 |      >>> x.item((2, 2))
 |      3
 |  
 |  itemset(...)
 |      a.itemset(*args)
 |      
 |      Insert scalar into an array (scalar is cast to array's dtype, if possible)
 |      
 |      There must be at least 1 argument, and define the last argument
 |      as *item*.  Then, ``a.itemset(*args)`` is equivalent to but faster
 |      than ``a[args] = item``.  The item should be a scalar value and `args`
 |      must select a single item in the array `a`.
 |      
 |      Parameters
 |      ----------
 |      \*args : Arguments
 |          If one argument: a scalar, only used in case `a` is of size 1.
 |          If two arguments: the last argument is the value to be set
 |          and must be a scalar, the first argument specifies a single array
 |          element location. It is either an int or a tuple.
 |      
 |      Notes
 |      -----
 |      Compared to indexing syntax, `itemset` provides some speed increase
 |      for placing a scalar into a particular location in an `ndarray`,
 |      if you must do this.  However, generally this is discouraged:
 |      among other problems, it complicates the appearance of the code.
 |      Also, when using `itemset` (and `item`) inside a loop, be sure
 |      to assign the methods to a local variable to avoid the attribute
 |      look-up at each loop iteration.
 |      
 |      Examples
 |      --------
 |      >>> x = np.random.randint(9, size=(3, 3))
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 8, 3],
 |             [8, 5, 3]])
 |      >>> x.itemset(4, 0)
 |      >>> x.itemset((2, 2), 9)
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 0, 3],
 |             [8, 5, 9]])
 |  
 |  max(...)
 |      a.max(axis=None, out=None, keepdims=False)
 |      
 |      Return the maximum along a given axis.
 |      
 |      Refer to `numpy.amax` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.amax : equivalent function
 |  
 |  mean(...)
 |      a.mean(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Returns the average of the array elements along given axis.
 |      
 |      Refer to `numpy.mean` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.mean : equivalent function
 |  
 |  min(...)
 |      a.min(axis=None, out=None, keepdims=False)
 |      
 |      Return the minimum along a given axis.
 |      
 |      Refer to `numpy.amin` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.amin : equivalent function
 |  
 |  newbyteorder(...)
 |      arr.newbyteorder(new_order='S')
 |      
 |      Return the array with the same data viewed with a different byte order.
 |      
 |      Equivalent to::
 |      
 |          arr.view(arr.dtype.newbytorder(new_order))
 |      
 |      Changes are also made in all fields and sub-arrays of the array data
 |      type.
 |      
 |      
 |      
 |      Parameters
 |      ----------
 |      new_order : string, optional
 |          Byte order to force; a value from the byte order specifications
 |          below. `new_order` codes can be any of:
 |      
 |          * 'S' - swap dtype from current to opposite endian
 |          * {'<', 'L'} - little endian
 |          * {'>', 'B'} - big endian
 |          * {'=', 'N'} - native order
 |          * {'|', 'I'} - ignore (no change to byte order)
 |      
 |          The default value ('S') results in swapping the current
 |          byte order. The code does a case-insensitive check on the first
 |          letter of `new_order` for the alternatives above.  For example,
 |          any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 |      
 |      
 |      Returns
 |      -------
 |      new_arr : array
 |          New array object with the dtype reflecting given change to the
 |          byte order.
 |  
 |  nonzero(...)
 |      a.nonzero()
 |      
 |      Return the indices of the elements that are non-zero.
 |      
 |      Refer to `numpy.nonzero` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.nonzero : equivalent function
 |  
 |  partition(...)
 |      a.partition(kth, axis=-1, kind='introselect', order=None)
 |      
 |      Rearranges the elements in the array in such a way that value of the
 |      element in kth position is in the position it would be in a sorted array.
 |      All elements smaller than the kth element are moved before this element and
 |      all equal or greater are moved behind it. The ordering of the elements in
 |      the two partitions is undefined.
 |      
 |      .. versionadded:: 1.8.0
 |      
 |      Parameters
 |      ----------
 |      kth : int or sequence of ints
 |          Element index to partition by. The kth element value will be in its
 |          final sorted position and all smaller elements will be moved before it
 |          and all equal or greater elements behind it.
 |          The order all elements in the partitions is undefined.
 |          If provided with a sequence of kth it will partition all elements
 |          indexed by kth of them into their sorted position at once.
 |      axis : int, optional
 |          Axis along which to sort. Default is -1, which means sort along the
 |          last axis.
 |      kind : {'introselect'}, optional
 |          Selection algorithm. Default is 'introselect'.
 |      order : str or list of str, optional
 |          When `a` is an array with fields defined, this argument specifies
 |          which fields to compare first, second, etc.  A single field can
 |          be specified as a string, and not all fields need be specified,
 |          but unspecified fields will still be used, in the order in which
 |          they come up in the dtype, to break ties.
 |      
 |      See Also
 |      --------
 |      numpy.partition : Return a parititioned copy of an array.
 |      argpartition : Indirect partition.
 |      sort : Full sort.
 |      
 |      Notes
 |      -----
 |      See ``np.partition`` for notes on the different algorithms.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([3, 4, 2, 1])
 |      >>> a.partition(3)
 |      >>> a
 |      array([2, 1, 3, 4])
 |      
 |      >>> a.partition((1, 3))
 |      array([1, 2, 3, 4])
 |  
 |  prod(...)
 |      a.prod(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Return the product of the array elements over the given axis
 |      
 |      Refer to `numpy.prod` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.prod : equivalent function
 |  
 |  ptp(...)
 |      a.ptp(axis=None, out=None)
 |      
 |      Peak to peak (maximum - minimum) value along a given axis.
 |      
 |      Refer to `numpy.ptp` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.ptp : equivalent function
 |  
 |  put(...)
 |      a.put(indices, values, mode='raise')
 |      
 |      Set ``a.flat[n] = values[n]`` for all `n` in indices.
 |      
 |      Refer to `numpy.put` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.put : equivalent function
 |  
 |  ravel(...)
 |      a.ravel([order])
 |      
 |      Return a flattened array.
 |      
 |      Refer to `numpy.ravel` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.ravel : equivalent function
 |      
 |      ndarray.flat : a flat iterator on the array.
 |  
 |  repeat(...)
 |      a.repeat(repeats, axis=None)
 |      
 |      Repeat elements of an array.
 |      
 |      Refer to `numpy.repeat` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.repeat : equivalent function
 |  
 |  reshape(...)
 |      a.reshape(shape, order='C')
 |      
 |      Returns an array containing the same data with a new shape.
 |      
 |      Refer to `numpy.reshape` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.reshape : equivalent function
 |      
 |      Notes
 |      -----
 |      Unlike the free function `numpy.reshape`, this method on `ndarray` allows
 |      the elements of the shape parameter to be passed in as separate arguments.
 |      For example, ``a.reshape(10, 11)`` is equivalent to
 |      ``a.reshape((10, 11))``.
 |  
 |  resize(...)
 |      a.resize(new_shape, refcheck=True)
 |      
 |      Change shape and size of array in-place.
 |      
 |      Parameters
 |      ----------
 |      new_shape : tuple of ints, or `n` ints
 |          Shape of resized array.
 |      refcheck : bool, optional
 |          If False, reference count will not be checked. Default is True.
 |      
 |      Returns
 |      -------
 |      None
 |      
 |      Raises
 |      ------
 |      ValueError
 |          If `a` does not own its own data or references or views to it exist,
 |          and the data memory must be changed.
 |          PyPy only: will always raise if the data memory must be changed, since
 |          there is no reliable way to determine if references or views to it
 |          exist.
 |      
 |      SystemError
 |          If the `order` keyword argument is specified. This behaviour is a
 |          bug in NumPy.
 |      
 |      See Also
 |      --------
 |      resize : Return a new array with the specified shape.
 |      
 |      Notes
 |      -----
 |      This reallocates space for the data area if necessary.
 |      
 |      Only contiguous arrays (data elements consecutive in memory) can be
 |      resized.
 |      
 |      The purpose of the reference count check is to make sure you
 |      do not use this array as a buffer for another Python object and then
 |      reallocate the memory. However, reference counts can increase in
 |      other ways so if you are sure that you have not shared the memory
 |      for this array with another Python object, then you may safely set
 |      `refcheck` to False.
 |      
 |      Examples
 |      --------
 |      Shrinking an array: array is flattened (in the order that the data are
 |      stored in memory), resized, and reshaped:
 |      
 |      >>> a = np.array([[0, 1], [2, 3]], order='C')
 |      >>> a.resize((2, 1))
 |      >>> a
 |      array([[0],
 |             [1]])
 |      
 |      >>> a = np.array([[0, 1], [2, 3]], order='F')
 |      >>> a.resize((2, 1))
 |      >>> a
 |      array([[0],
 |             [2]])
 |      
 |      Enlarging an array: as above, but missing entries are filled with zeros:
 |      
 |      >>> b = np.array([[0, 1], [2, 3]])
 |      >>> b.resize(2, 3) # new_shape parameter doesn't have to be a tuple
 |      >>> b
 |      array([[0, 1, 2],
 |             [3, 0, 0]])
 |      
 |      Referencing an array prevents resizing...
 |      
 |      >>> c = a
 |      >>> a.resize((1, 1))
 |      Traceback (most recent call last):
 |      ...
 |      ValueError: cannot resize an array that has been referenced ...
 |      
 |      Unless `refcheck` is False:
 |      
 |      >>> a.resize((1, 1), refcheck=False)
 |      >>> a
 |      array([[0]])
 |      >>> c
 |      array([[0]])
 |  
 |  round(...)
 |      a.round(decimals=0, out=None)
 |      
 |      Return `a` with each element rounded to the given number of decimals.
 |      
 |      Refer to `numpy.around` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.around : equivalent function
 |  
 |  searchsorted(...)
 |      a.searchsorted(v, side='left', sorter=None)
 |      
 |      Find indices where elements of v should be inserted in a to maintain order.
 |      
 |      For full documentation, see `numpy.searchsorted`
 |      
 |      See Also
 |      --------
 |      numpy.searchsorted : equivalent function
 |  
 |  setfield(...)
 |      a.setfield(val, dtype, offset=0)
 |      
 |      Put a value into a specified place in a field defined by a data-type.
 |      
 |      Place `val` into `a`'s field defined by `dtype` and beginning `offset`
 |      bytes into the field.
 |      
 |      Parameters
 |      ----------
 |      val : object
 |          Value to be placed in field.
 |      dtype : dtype object
 |          Data-type of the field in which to place `val`.
 |      offset : int, optional
 |          The number of bytes into the field at which to place `val`.
 |      
 |      Returns
 |      -------
 |      None
 |      
 |      See Also
 |      --------
 |      getfield
 |      
 |      Examples
 |      --------
 |      >>> x = np.eye(3)
 |      >>> x.getfield(np.float64)
 |      array([[ 1.,  0.,  0.],
 |             [ 0.,  1.,  0.],
 |             [ 0.,  0.,  1.]])
 |      >>> x.setfield(3, np.int32)
 |      >>> x.getfield(np.int32)
 |      array([[3, 3, 3],
 |             [3, 3, 3],
 |             [3, 3, 3]])
 |      >>> x
 |      array([[  1.00000000e+000,   1.48219694e-323,   1.48219694e-323],
 |             [  1.48219694e-323,   1.00000000e+000,   1.48219694e-323],
 |             [  1.48219694e-323,   1.48219694e-323,   1.00000000e+000]])
 |      >>> x.setfield(np.eye(3), np.int32)
 |      >>> x
 |      array([[ 1.,  0.,  0.],
 |             [ 0.,  1.,  0.],
 |             [ 0.,  0.,  1.]])
 |  
 |  setflags(...)
 |      a.setflags(write=None, align=None, uic=None)
 |      
 |      Set array flags WRITEABLE, ALIGNED, (WRITEBACKIFCOPY and UPDATEIFCOPY),
 |      respectively.
 |      
 |      These Boolean-valued flags affect how numpy interprets the memory
 |      area used by `a` (see Notes below). The ALIGNED flag can only
 |      be set to True if the data is actually aligned according to the type.
 |      The WRITEBACKIFCOPY and (deprecated) UPDATEIFCOPY flags can never be set
 |      to True. The flag WRITEABLE can only be set to True if the array owns its
 |      own memory, or the ultimate owner of the memory exposes a writeable buffer
 |      interface, or is a string. (The exception for string is made so that
 |      unpickling can be done without copying memory.)
 |      
 |      Parameters
 |      ----------
 |      write : bool, optional
 |          Describes whether or not `a` can be written to.
 |      align : bool, optional
 |          Describes whether or not `a` is aligned properly for its type.
 |      uic : bool, optional
 |          Describes whether or not `a` is a copy of another ""base"" array.
 |      
 |      Notes
 |      -----
 |      Array flags provide information about how the memory area used
 |      for the array is to be interpreted. There are 7 Boolean flags
 |      in use, only four of which can be changed by the user:
 |      WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED.
 |      
 |      WRITEABLE (W) the data area can be written to;
 |      
 |      ALIGNED (A) the data and strides are aligned appropriately for the hardware
 |      (as determined by the compiler);
 |      
 |      UPDATEIFCOPY (U) (deprecated), replaced by WRITEBACKIFCOPY;
 |      
 |      WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced
 |      by .base). When the C-API function PyArray_ResolveWritebackIfCopy is
 |      called, the base array will be updated with the contents of this array.
 |      
 |      All flags can be accessed using the single (upper case) letter as well
 |      as the full name.
 |      
 |      Examples
 |      --------
 |      >>> y
 |      array([[3, 1, 7],
 |             [2, 0, 0],
 |             [8, 5, 9]])
 |      >>> y.flags
 |        C_CONTIGUOUS : True
 |        F_CONTIGUOUS : False
 |        OWNDATA : True
 |        WRITEABLE : True
 |        ALIGNED : True
 |        WRITEBACKIFCOPY : False
 |        UPDATEIFCOPY : False
 |      >>> y.setflags(write=0, align=0)
 |      >>> y.flags
 |        C_CONTIGUOUS : True
 |        F_CONTIGUOUS : False
 |        OWNDATA : True
 |        WRITEABLE : False
 |        ALIGNED : False
 |        WRITEBACKIFCOPY : False
 |        UPDATEIFCOPY : False
 |      >>> y.setflags(uic=1)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: cannot set WRITEBACKIFCOPY flag to True
 |  
 |  sort(...)
 |      a.sort(axis=-1, kind='quicksort', order=None)
 |      
 |      Sort an array, in-place.
 |      
 |      Parameters
 |      ----------
 |      axis : int, optional
 |          Axis along which to sort. Default is -1, which means sort along the
 |          last axis.
 |      kind : {'quicksort', 'mergesort', 'heapsort'}, optional
 |          Sorting algorithm. Default is 'quicksort'.
 |      order : str or list of str, optional
 |          When `a` is an array with fields defined, this argument specifies
 |          which fields to compare first, second, etc.  A single field can
 |          be specified as a string, and not all fields need be specified,
 |          but unspecified fields will still be used, in the order in which
 |          they come up in the dtype, to break ties.
 |      
 |      See Also
 |      --------
 |      numpy.sort : Return a sorted copy of an array.
 |      argsort : Indirect sort.
 |      lexsort : Indirect stable sort on multiple keys.
 |      searchsorted : Find elements in sorted array.
 |      partition: Partial sort.
 |      
 |      Notes
 |      -----
 |      See ``sort`` for notes on the different sorting algorithms.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1,4], [3,1]])
 |      >>> a.sort(axis=1)
 |      >>> a
 |      array([[1, 4],
 |             [1, 3]])
 |      >>> a.sort(axis=0)
 |      >>> a
 |      array([[1, 3],
 |             [1, 4]])
 |      
 |      Use the `order` keyword to specify a field to use when sorting a
 |      structured array:
 |      
 |      >>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])
 |      >>> a.sort(order='y')
 |      >>> a
 |      array([('c', 1), ('a', 2)],
 |            dtype=[('x', '|S1'), ('y', '<i4')])
 |  
 |  squeeze(...)
 |      a.squeeze(axis=None)
 |      
 |      Remove single-dimensional entries from the shape of `a`.
 |      
 |      Refer to `numpy.squeeze` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.squeeze : equivalent function
 |  
 |  std(...)
 |      a.std(axis=None, dtype=None, out=None, ddof=0, keepdims=False)
 |      
 |      Returns the standard deviation of the array elements along given axis.
 |      
 |      Refer to `numpy.std` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.std : equivalent function
 |  
 |  sum(...)
 |      a.sum(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Return the sum of the array elements over the given axis.
 |      
 |      Refer to `numpy.sum` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.sum : equivalent function
 |  
 |  swapaxes(...)
 |      a.swapaxes(axis1, axis2)
 |      
 |      Return a view of the array with `axis1` and `axis2` interchanged.
 |      
 |      Refer to `numpy.swapaxes` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.swapaxes : equivalent function
 |  
 |  take(...)
 |      a.take(indices, axis=None, out=None, mode='raise')
 |      
 |      Return an array formed from the elements of `a` at the given indices.
 |      
 |      Refer to `numpy.take` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.take : equivalent function
 |  
 |  tobytes(...)
 |      a.tobytes(order='C')
 |      
 |      Construct Python bytes containing the raw data bytes in the array.
 |      
 |      Constructs Python bytes showing a copy of the raw contents of
 |      data memory. The bytes object can be produced in either 'C' or 'Fortran',
 |      or 'Any' order (the default is 'C'-order). 'Any' order means C-order
 |      unless the F_CONTIGUOUS flag in the array is set, in which case it
 |      means 'Fortran' order.
 |      
 |      .. versionadded:: 1.9.0
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', None}, optional
 |          Order of the data for multidimensional arrays:
 |          C, Fortran, or the same as for the original array.
 |      
 |      Returns
 |      -------
 |      s : bytes
 |          Python bytes exhibiting a copy of `a`'s raw data.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[0, 1], [2, 3]])
 |      >>> x.tobytes()
 |      b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
 |      >>> x.tobytes('C') == x.tobytes()
 |      True
 |      >>> x.tobytes('F')
 |      b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
 |  
 |  tofile(...)
 |      a.tofile(fid, sep="""", format=""%s"")
 |      
 |      Write array to a file as text or binary (default).
 |      
 |      Data is always written in 'C' order, independent of the order of `a`.
 |      The data produced by this method can be recovered using the function
 |      fromfile().
 |      
 |      Parameters
 |      ----------
 |      fid : file or str
 |          An open file object, or a string containing a filename.
 |      sep : str
 |          Separator between array items for text output.
 |          If """" (empty), a binary file is written, equivalent to
 |          ``file.write(a.tobytes())``.
 |      format : str
 |          Format string for text file output.
 |          Each entry in the array is formatted to text by first converting
 |          it to the closest Python type, and then using ""format"" % item.
 |      
 |      Notes
 |      -----
 |      This is a convenience function for quick storage of array data.
 |      Information on endianness and precision is lost, so this method is not a
 |      good choice for files intended to archive data or transport data between
 |      machines with different endianness. Some of these problems can be overcome
 |      by outputting the data as text files, at the expense of speed and file
 |      size.
 |  
 |  tolist(...)
 |      a.tolist()
 |      
 |      Return the array as a (possibly nested) list.
 |      
 |      Return a copy of the array data as a (nested) Python list.
 |      Data items are converted to the nearest compatible Python type.
 |      
 |      Parameters
 |      ----------
 |      none
 |      
 |      Returns
 |      -------
 |      y : list
 |          The possibly nested list of array elements.
 |      
 |      Notes
 |      -----
 |      The array may be recreated, ``a = np.array(a.tolist())``.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([1, 2])
 |      >>> a.tolist()
 |      [1, 2]
 |      >>> a = np.array([[1, 2], [3, 4]])
 |      >>> list(a)
 |      [array([1, 2]), array([3, 4])]
 |      >>> a.tolist()
 |      [[1, 2], [3, 4]]
 |  
 |  tostring(...)
 |      a.tostring(order='C')
 |      
 |      Construct Python bytes containing the raw data bytes in the array.
 |      
 |      Constructs Python bytes showing a copy of the raw contents of
 |      data memory. The bytes object can be produced in either 'C' or 'Fortran',
 |      or 'Any' order (the default is 'C'-order). 'Any' order means C-order
 |      unless the F_CONTIGUOUS flag in the array is set, in which case it
 |      means 'Fortran' order.
 |      
 |      This function is a compatibility alias for tobytes. Despite its name it returns bytes not strings.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', None}, optional
 |          Order of the data for multidimensional arrays:
 |          C, Fortran, or the same as for the original array.
 |      
 |      Returns
 |      -------
 |      s : bytes
 |          Python bytes exhibiting a copy of `a`'s raw data.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[0, 1], [2, 3]])
 |      >>> x.tobytes()
 |      b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
 |      >>> x.tobytes('C') == x.tobytes()
 |      True
 |      >>> x.tobytes('F')
 |      b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
 |  
 |  trace(...)
 |      a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)
 |      
 |      Return the sum along diagonals of the array.
 |      
 |      Refer to `numpy.trace` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.trace : equivalent function
 |  
 |  transpose(...)
 |      a.transpose(*axes)
 |      
 |      Returns a view of the array with axes transposed.
 |      
 |      For a 1-D array, this has no effect. (To change between column and
 |      row vectors, first cast the 1-D array into a matrix object.)
 |      For a 2-D array, this is the usual matrix transpose.
 |      For an n-D array, if axes are given, their order indicates how the
 |      axes are permuted (see Examples). If axes are not provided and
 |      ``a.shape = (i[0], i[1], ... i[n-2], i[n-1])``, then
 |      ``a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0])``.
 |      
 |      Parameters
 |      ----------
 |      axes : None, tuple of ints, or `n` ints
 |      
 |       * None or no argument: reverses the order of the axes.
 |      
 |       * tuple of ints: `i` in the `j`-th place in the tuple means `a`'s
 |         `i`-th axis becomes `a.transpose()`'s `j`-th axis.
 |      
 |       * `n` ints: same as an n-tuple of the same ints (this form is
 |         intended simply as a ""convenience"" alternative to the tuple form)
 |      
 |      Returns
 |      -------
 |      out : ndarray
 |          View of `a`, with axes suitably permuted.
 |      
 |      See Also
 |      --------
 |      ndarray.T : Array property returning the array transposed.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1, 2], [3, 4]])
 |      >>> a
 |      array([[1, 2],
 |             [3, 4]])
 |      >>> a.transpose()
 |      array([[1, 3],
 |             [2, 4]])
 |      >>> a.transpose((1, 0))
 |      array([[1, 3],
 |             [2, 4]])
 |      >>> a.transpose(1, 0)
 |      array([[1, 3],
 |             [2, 4]])
 |  
 |  var(...)
 |      a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False)
 |      
 |      Returns the variance of the array elements, along given axis.
 |      
 |      Refer to `numpy.var` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.var : equivalent function
 |  
 |  view(...)
 |      a.view(dtype=None, type=None)
 |      
 |      New view of array with the same data.
 |      
 |      Parameters
 |      ----------
 |      dtype : data-type or ndarray sub-class, optional
 |          Data-type descriptor of the returned view, e.g., float32 or int16. The
 |          default, None, results in the view having the same data-type as `a`.
 |          This argument can also be specified as an ndarray sub-class, which
 |          then specifies the type of the returned object (this is equivalent to
 |          setting the ``type`` parameter).
 |      type : Python type, optional
 |          Type of the returned view, e.g., ndarray or matrix.  Again, the
 |          default None results in type preservation.
 |      
 |      Notes
 |      -----
 |      ``a.view()`` is used two different ways:
 |      
 |      ``a.view(some_dtype)`` or ``a.view(dtype=some_dtype)`` constructs a view
 |      of the array's memory with a different data-type.  This can cause a
 |      reinterpretation of the bytes of memory.
 |      
 |      ``a.view(ndarray_subclass)`` or ``a.view(type=ndarray_subclass)`` just
 |      returns an instance of `ndarray_subclass` that looks at the same array
 |      (same shape, dtype, etc.)  This does not cause a reinterpretation of the
 |      memory.
 |      
 |      For ``a.view(some_dtype)``, if ``some_dtype`` has a different number of
 |      bytes per entry than the previous dtype (for example, converting a
 |      regular array to a structured array), then the behavior of the view
 |      cannot be predicted just from the superficial appearance of ``a`` (shown
 |      by ``print(a)``). It also depends on exactly how ``a`` is stored in
 |      memory. Therefore if ``a`` is C-ordered versus fortran-ordered, versus
 |      defined as a slice or transpose, etc., the view may give different
 |      results.
 |      
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])
 |      
 |      Viewing array data using a different type and dtype:
 |      
 |      >>> y = x.view(dtype=np.int16, type=np.matrix)
 |      >>> y
 |      matrix([[513]], dtype=int16)
 |      >>> print(type(y))
 |      <class 'numpy.matrixlib.defmatrix.matrix'>
 |      
 |      Creating a view on a structured array so it can be used in calculations
 |      
 |      >>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)])
 |      >>> xv = x.view(dtype=np.int8).reshape(-1,2)
 |      >>> xv
 |      array([[1, 2],
 |             [3, 4]], dtype=int8)
 |      >>> xv.mean(0)
 |      array([ 2.,  3.])
 |      
 |      Making changes to the view changes the underlying array
 |      
 |      >>> xv[0,1] = 20
 |      >>> print(x)
 |      [(1, 20) (3, 4)]
 |      
 |      Using a view to convert an array to a recarray:
 |      
 |      >>> z = x.view(np.recarray)
 |      >>> z.a
 |      array([1], dtype=int8)
 |      
 |      Views share data:
 |      
 |      >>> x[0] = (9, 10)
 |      >>> z[0]
 |      (9, 10)
 |      
 |      Views that change the dtype size (bytes per entry) should normally be
 |      avoided on arrays defined by slices, transposes, fortran-ordering, etc.:
 |      
 |      >>> x = np.array([[1,2,3],[4,5,6]], dtype=np.int16)
 |      >>> y = x[:, 0:2]
 |      >>> y
 |      array([[1, 2],
 |             [4, 5]], dtype=int16)
 |      >>> y.view(dtype=[('width', np.int16), ('length', np.int16)])
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: new type not compatible with array.
 |      >>> z = y.copy()
 |      >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
 |      array([[(1, 2)],
 |             [(4, 5)]], dtype=[('width', '<i2'), ('length', '<i2')])
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from numpy.ndarray:
 |  
 |  T
 |      Same as self.transpose(), except that self is returned if
 |      self.ndim < 2.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[1.,2.],[3.,4.]])
 |      >>> x
 |      array([[ 1.,  2.],
 |             [ 3.,  4.]])
 |      >>> x.T
 |      array([[ 1.,  3.],
 |             [ 2.,  4.]])
 |      >>> x = np.array([1.,2.,3.,4.])
 |      >>> x
 |      array([ 1.,  2.,  3.,  4.])
 |      >>> x.T
 |      array([ 1.,  2.,  3.,  4.])
 |  
 |  __array_finalize__
 |      None.
 |  
 |  __array_interface__
 |      Array protocol: Python side.
 |  
 |  __array_priority__
 |      Array priority.
 |  
 |  __array_struct__
 |      Array protocol: C-struct side.
 |  
 |  base
 |      Base object if memory is from some other object.
 |      
 |      Examples
 |      --------
 |      The base of an array that owns its memory is None:
 |      
 |      >>> x = np.array([1,2,3,4])
 |      >>> x.base is None
 |      True
 |      
 |      Slicing creates a view, whose memory is shared with x:
 |      
 |      >>> y = x[2:]
 |      >>> y.base is x
 |      True
 |  
 |  ctypes
 |      An object to simplify the interaction of the array with the ctypes
 |      module.
 |      
 |      This attribute creates an object that makes it easier to use arrays
 |      when calling shared libraries with the ctypes module. The returned
 |      object has, among others, data, shape, and strides attributes (see
 |      Notes below) which themselves return ctypes objects that can be used
 |      as arguments to a shared library.
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      c : Python object
 |          Possessing attributes data, shape, strides, etc.
 |      
 |      See Also
 |      --------
 |      numpy.ctypeslib
 |      
 |      Notes
 |      -----
 |      Below are the public attributes of this object which were documented
 |      in ""Guide to NumPy"" (we have omitted undocumented public attributes,
 |      as well as documented private attributes):
 |      
 |      * data: A pointer to the memory area of the array as a Python integer.
 |        This memory area may contain data that is not aligned, or not in correct
 |        byte-order. The memory area may not even be writeable. The array
 |        flags and data-type of this array should be respected when passing this
 |        attribute to arbitrary C-code to avoid trouble that can include Python
 |        crashing. User Beware! The value of this attribute is exactly the same
 |        as self._array_interface_['data'][0].
 |      
 |      * shape (c_intp*self.ndim): A ctypes array of length self.ndim where
 |        the basetype is the C-integer corresponding to dtype('p') on this
 |        platform. This base-type could be c_int, c_long, or c_longlong
 |        depending on the platform. The c_intp type is defined accordingly in
 |        numpy.ctypeslib. The ctypes array contains the shape of the underlying
 |        array.
 |      
 |      * strides (c_intp*self.ndim): A ctypes array of length self.ndim where
 |        the basetype is the same as for the shape attribute. This ctypes array
 |        contains the strides information from the underlying array. This strides
 |        information is important for showing how many bytes must be jumped to
 |        get to the next element in the array.
 |      
 |      * data_as(obj): Return the data pointer cast to a particular c-types object.
 |        For example, calling self._as_parameter_ is equivalent to
 |        self.data_as(ctypes.c_void_p). Perhaps you want to use the data as a
 |        pointer to a ctypes array of floating-point data:
 |        self.data_as(ctypes.POINTER(ctypes.c_double)).
 |      
 |      * shape_as(obj): Return the shape tuple as an array of some other c-types
 |        type. For example: self.shape_as(ctypes.c_short).
 |      
 |      * strides_as(obj): Return the strides tuple as an array of some other
 |        c-types type. For example: self.strides_as(ctypes.c_longlong).
 |      
 |      Be careful using the ctypes attribute - especially on temporary
 |      arrays or arrays constructed on the fly. For example, calling
 |      ``(a+b).ctypes.data_as(ctypes.c_void_p)`` returns a pointer to memory
 |      that is invalid because the array created as (a+b) is deallocated
 |      before the next Python statement. You can avoid this problem using
 |      either ``c=a+b`` or ``ct=(a+b).ctypes``. In the latter case, ct will
 |      hold a reference to the array until ct is deleted or re-assigned.
 |      
 |      If the ctypes module is not available, then the ctypes attribute
 |      of array objects still returns something useful, but ctypes objects
 |      are not returned and errors may be raised instead. In particular,
 |      the object will still have the as parameter attribute which will
 |      return an integer equal to the data attribute.
 |      
 |      Examples
 |      --------
 |      >>> import ctypes
 |      >>> x
 |      array([[0, 1],
 |             [2, 3]])
 |      >>> x.ctypes.data
 |      30439712
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long))
 |      <ctypes.LP_c_long object at 0x01F01300>
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)).contents
 |      c_long(0)
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_longlong)).contents
 |      c_longlong(4294967296L)
 |      >>> x.ctypes.shape
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FFD580>
 |      >>> x.ctypes.shape_as(ctypes.c_long)
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
 |      >>> x.ctypes.strides
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
 |      >>> x.ctypes.strides_as(ctypes.c_longlong)
 |      <numpy.core._internal.c_longlong_Array_2 object at 0x01F01300>
 |  
 |  data
 |      Python buffer object pointing to the start of the array's data.
 |  
 |  dtype
 |      Data-type of the array's elements.
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      d : numpy dtype object
 |      
 |      See Also
 |      --------
 |      numpy.dtype
 |      
 |      Examples
 |      --------
 |      >>> x
 |      array([[0, 1],
 |             [2, 3]])
 |      >>> x.dtype
 |      dtype('int32')
 |      >>> type(x.dtype)
 |      <type 'numpy.dtype'>
 |  
 |  flags
 |      Information about the memory layout of the array.
 |      
 |      Attributes
 |      ----------
 |      C_CONTIGUOUS (C)
 |          The data is in a single, C-style contiguous segment.
 |      F_CONTIGUOUS (F)
 |          The data is in a single, Fortran-style contiguous segment.
 |      OWNDATA (O)
 |          The array owns the memory it uses or borrows it from another object.
 |      WRITEABLE (W)
 |          The data area can be written to.  Setting this to False locks
 |          the data, making it read-only.  A view (slice, etc.) inherits WRITEABLE
 |          from its base array at creation time, but a view of a writeable
 |          array may be subsequently locked while the base array remains writeable.
 |          (The opposite is not true, in that a view of a locked array may not
 |          be made writeable.  However, currently, locking a base object does not
 |          lock any views that already reference it, so under that circumstance it
 |          is possible to alter the contents of a locked array via a previously
 |          created writeable view onto it.)  Attempting to change a non-writeable
 |          array raises a RuntimeError exception.
 |      ALIGNED (A)
 |          The data and all elements are aligned appropriately for the hardware.
 |      WRITEBACKIFCOPY (X)
 |          This array is a copy of some other array. The C-API function
 |          PyArray_ResolveWritebackIfCopy must be called before deallocating
 |          to the base array will be updated with the contents of this array.
 |      UPDATEIFCOPY (U)
 |          (Deprecated, use WRITEBACKIFCOPY) This array is a copy of some other array.
 |          When this array is
 |          deallocated, the base array will be updated with the contents of
 |          this array.
 |      FNC
 |          F_CONTIGUOUS and not C_CONTIGUOUS.
 |      FORC
 |          F_CONTIGUOUS or C_CONTIGUOUS (one-segment test).
 |      BEHAVED (B)
 |          ALIGNED and WRITEABLE.
 |      CARRAY (CA)
 |          BEHAVED and C_CONTIGUOUS.
 |      FARRAY (FA)
 |          BEHAVED and F_CONTIGUOUS and not C_CONTIGUOUS.
 |      
 |      Notes
 |      -----
 |      The `flags` object can be accessed dictionary-like (as in ``a.flags['WRITEABLE']``),
 |      or by using lowercased attribute names (as in ``a.flags.writeable``). Short flag
 |      names are only supported in dictionary access.
 |      
 |      Only the WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED flags can be
 |      changed by the user, via direct assignment to the attribute or dictionary
 |      entry, or by calling `ndarray.setflags`.
 |      
 |      The array flags cannot be set arbitrarily:
 |      
 |      - UPDATEIFCOPY can only be set ``False``.
 |      - WRITEBACKIFCOPY can only be set ``False``.
 |      - ALIGNED can only be set ``True`` if the data is truly aligned.
 |      - WRITEABLE can only be set ``True`` if the array owns its own memory
 |        or the ultimate owner of the memory exposes a writeable buffer
 |        interface or is a string.
 |      
 |      Arrays can be both C-style and Fortran-style contiguous simultaneously.
 |      This is clear for 1-dimensional arrays, but can also be true for higher
 |      dimensional arrays.
 |      
 |      Even for contiguous arrays a stride for a given dimension
 |      ``arr.strides[dim]`` may be *arbitrary* if ``arr.shape[dim] == 1``
 |      or the array has no elements.
 |      It does *not* generally hold that ``self.strides[-1] == self.itemsize``
 |      for C-style contiguous arrays or ``self.strides[0] == self.itemsize`` for
 |      Fortran-style contiguous arrays is true.
 |  
 |  flat
 |      A 1-D iterator over the array.
 |      
 |      This is a `numpy.flatiter` instance, which acts similarly to, but is not
 |      a subclass of, Python's built-in iterator object.
 |      
 |      See Also
 |      --------
 |      flatten : Return a copy of the array collapsed into one dimension.
 |      
 |      flatiter
 |      
 |      Examples
 |      --------
 |      >>> x = np.arange(1, 7).reshape(2, 3)
 |      >>> x
 |      array([[1, 2, 3],
 |             [4, 5, 6]])
 |      >>> x.flat[3]
 |      4
 |      >>> x.T
 |      array([[1, 4],
 |             [2, 5],
 |             [3, 6]])
 |      >>> x.T.flat[3]
 |      5
 |      >>> type(x.flat)
 |      <type 'numpy.flatiter'>
 |      
 |      An assignment example:
 |      
 |      >>> x.flat = 3; x
 |      array([[3, 3, 3],
 |             [3, 3, 3]])
 |      >>> x.flat[[1,4]] = 1; x
 |      array([[3, 1, 3],
 |             [3, 1, 3]])
 |  
 |  imag
 |      The imaginary part of the array.
 |      
 |      Examples
 |      --------
 |      >>> x = np.sqrt([1+0j, 0+1j])
 |      >>> x.imag
 |      array([ 0.        ,  0.70710678])
 |      >>> x.imag.dtype
 |      dtype('float64')
 |  
 |  itemsize
 |      Length of one array element in bytes.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1,2,3], dtype=np.float64)
 |      >>> x.itemsize
 |      8
 |      >>> x = np.array([1,2,3], dtype=np.complex128)
 |      >>> x.itemsize
 |      16
 |  
 |  nbytes
 |      Total bytes consumed by the elements of the array.
 |      
 |      Notes
 |      -----
 |      Does not include memory consumed by non-element attributes of the
 |      array object.
 |      
 |      Examples
 |      --------
 |      >>> x = np.zeros((3,5,2), dtype=np.complex128)
 |      >>> x.nbytes
 |      480
 |      >>> np.prod(x.shape) * x.itemsize
 |      480
 |  
 |  ndim
 |      Number of array dimensions.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 3])
 |      >>> x.ndim
 |      1
 |      >>> y = np.zeros((2, 3, 4))
 |      >>> y.ndim
 |      3
 |  
 |  real
 |      The real part of the array.
 |      
 |      Examples
 |      --------
 |      >>> x = np.sqrt([1+0j, 0+1j])
 |      >>> x.real
 |      array([ 1.        ,  0.70710678])
 |      >>> x.real.dtype
 |      dtype('float64')
 |      
 |      See Also
 |      --------
 |      numpy.real : equivalent function
 |  
 |  shape
 |      Tuple of array dimensions.
 |      
 |      The shape property is usually used to get the current shape of an array,
 |      but may also be used to reshape the array in-place by assigning a tuple of
 |      array dimensions to it.  As with `numpy.reshape`, one of the new shape
 |      dimensions can be -1, in which case its value is inferred from the size of
 |      the array and the remaining dimensions. Reshaping an array in-place will
 |      fail if a copy is required.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 3, 4])
 |      >>> x.shape
 |      (4,)
 |      >>> y = np.zeros((2, 3, 4))
 |      >>> y.shape
 |      (2, 3, 4)
 |      >>> y.shape = (3, 8)
 |      >>> y
 |      array([[ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
 |             [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
 |             [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.]])
 |      >>> y.shape = (3, 6)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: total size of new array must be unchanged
 |      >>> np.zeros((4,2))[::2].shape = (-1,)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      AttributeError: incompatible shape for a non-contiguous array
 |      
 |      See Also
 |      --------
 |      numpy.reshape : similar function
 |      ndarray.reshape : similar method
 |  
 |  size
 |      Number of elements in the array.
 |      
 |      Equivalent to ``np.prod(a.shape)``, i.e., the product of the array's
 |      dimensions.
 |      
 |      Examples
 |      --------
 |      >>> x = np.zeros((3, 5, 2), dtype=np.complex128)
 |      >>> x.size
 |      30
 |      >>> np.prod(x.shape)
 |      30
 |  
 |  strides
 |      Tuple of bytes to step in each dimension when traversing an array.
 |      
 |      The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a`
 |      is::
 |      
 |          offset = sum(np.array(i) * a.strides)
 |      
 |      A more detailed explanation of strides can be found in the
 |      ""ndarray.rst"" file in the NumPy reference guide.
 |      
 |      Notes
 |      -----
 |      Imagine an array of 32-bit integers (each 4 bytes)::
 |      
 |        x = np.array([[0, 1, 2, 3, 4],
 |                      [5, 6, 7, 8, 9]], dtype=np.int32)
 |      
 |      This array is stored in memory as 40 bytes, one after the other
 |      (known as a contiguous block of memory).  The strides of an array tell
 |      us how many bytes we have to skip in memory to move to the next position
 |      along a certain axis.  For example, we have to skip 4 bytes (1 value) to
 |      move to the next column, but 20 bytes (5 values) to get to the same
 |      position in the next row.  As such, the strides for the array `x` will be
 |      ``(20, 4)``.
 |      
 |      See Also
 |      --------
 |      numpy.lib.stride_tricks.as_strided
 |      
 |      Examples
 |      --------
 |      >>> y = np.reshape(np.arange(2*3*4), (2,3,4))
 |      >>> y
 |      array([[[ 0,  1,  2,  3],
 |              [ 4,  5,  6,  7],
 |              [ 8,  9, 10, 11]],
 |             [[12, 13, 14, 15],
 |              [16, 17, 18, 19],
 |              [20, 21, 22, 23]]])
 |      >>> y.strides
 |      (48, 16, 4)
 |      >>> y[1,1,1]
 |      17
 |      >>> offset=sum(y.strides * np.array((1,1,1)))
 |      >>> offset/y.itemsize
 |      17
 |      
 |      >>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0)
 |      >>> x.strides
 |      (32, 4, 224, 1344)
 |      >>> i = np.array([3,5,2,2])
 |      >>> offset = sum(i * x.strides)
 |      >>> x[3,5,2,2]
 |      813
 |      >>> offset / x.itemsize
 |      813
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from numpy.ndarray:
 |  
 |  __hash__ = None
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.matlab.mio5.MatlabFunction,io.matlab.mio5,MatlabFunction,"Python Library Documentation: class MatlabFunction in module scipy.io.matlab.mio5_params

class MatlabFunction(numpy.ndarray)
 |  Subclass to signal this is a matlab function
 |  
 |  Method resolution order:
 |      MatlabFunction
 |      numpy.ndarray
 |      builtins.object
 |  
 |  Static methods defined here:
 |  
 |  __new__(cls, input_array)
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from numpy.ndarray:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __array__(...)
 |      a.__array__(|dtype) -> reference if type unchanged, copy otherwise.
 |      
 |      Returns either a new reference to self if dtype is not given or a new array
 |      of provided data type if dtype is different from the current dtype of the
 |      array.
 |  
 |  __array_prepare__(...)
 |      a.__array_prepare__(obj) -> Object of same type as ndarray object obj.
 |  
 |  __array_ufunc__(...)
 |  
 |  __array_wrap__(...)
 |      a.__array_wrap__(obj) -> Object of same type as ndarray object a.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __complex__(...)
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __copy__(...)
 |      a.__copy__()
 |      
 |      Used if :func:`copy.copy` is called on an array. Returns a copy of the array.
 |      
 |      Equivalent to ``a.copy(order='K')``.
 |  
 |  __deepcopy__(...)
 |      a.__deepcopy__(memo, /) -> Deep copy of array.
 |      
 |      Used if :func:`copy.deepcopy` is called on an array.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __format__(...)
 |      default object formatter
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iadd__(self, value, /)
 |      Return self+=value.
 |  
 |  __iand__(self, value, /)
 |      Return self&=value.
 |  
 |  __ifloordiv__(self, value, /)
 |      Return self//=value.
 |  
 |  __ilshift__(self, value, /)
 |      Return self<<=value.
 |  
 |  __imatmul__(self, value, /)
 |      Return self@=value.
 |  
 |  __imod__(self, value, /)
 |      Return self%=value.
 |  
 |  __imul__(self, value, /)
 |      Return self*=value.
 |  
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __ior__(self, value, /)
 |      Return self|=value.
 |  
 |  __ipow__(self, value, /)
 |      Return self**=value.
 |  
 |  __irshift__(self, value, /)
 |      Return self>>=value.
 |  
 |  __isub__(self, value, /)
 |      Return self-=value.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __itruediv__(self, value, /)
 |      Return self/=value.
 |  
 |  __ixor__(self, value, /)
 |      Return self^=value.
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __matmul__(self, value, /)
 |      Return self@value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __reduce__(...)
 |      a.__reduce__()
 |      
 |      For pickling.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmatmul__(self, value, /)
 |      Return value@self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __setstate__(...)
 |      a.__setstate__(state, /)
 |      
 |      For unpickling.
 |      
 |      The `state` argument must be a sequence that contains the following
 |      elements:
 |      
 |      Parameters
 |      ----------
 |      version : int
 |          optional pickle version. If omitted defaults to 0.
 |      shape : tuple
 |      dtype : data-type
 |      isFortran : bool
 |      rawdata : string or list
 |          a binary string with the data (or a list if 'a' is an object array)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  all(...)
 |      a.all(axis=None, out=None, keepdims=False)
 |      
 |      Returns True if all elements evaluate to True.
 |      
 |      Refer to `numpy.all` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.all : equivalent function
 |  
 |  any(...)
 |      a.any(axis=None, out=None, keepdims=False)
 |      
 |      Returns True if any of the elements of `a` evaluate to True.
 |      
 |      Refer to `numpy.any` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.any : equivalent function
 |  
 |  argmax(...)
 |      a.argmax(axis=None, out=None)
 |      
 |      Return indices of the maximum values along the given axis.
 |      
 |      Refer to `numpy.argmax` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argmax : equivalent function
 |  
 |  argmin(...)
 |      a.argmin(axis=None, out=None)
 |      
 |      Return indices of the minimum values along the given axis of `a`.
 |      
 |      Refer to `numpy.argmin` for detailed documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argmin : equivalent function
 |  
 |  argpartition(...)
 |      a.argpartition(kth, axis=-1, kind='introselect', order=None)
 |      
 |      Returns the indices that would partition this array.
 |      
 |      Refer to `numpy.argpartition` for full documentation.
 |      
 |      .. versionadded:: 1.8.0
 |      
 |      See Also
 |      --------
 |      numpy.argpartition : equivalent function
 |  
 |  argsort(...)
 |      a.argsort(axis=-1, kind='quicksort', order=None)
 |      
 |      Returns the indices that would sort this array.
 |      
 |      Refer to `numpy.argsort` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argsort : equivalent function
 |  
 |  astype(...)
 |      a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)
 |      
 |      Copy of the array, cast to a specified type.
 |      
 |      Parameters
 |      ----------
 |      dtype : str or dtype
 |          Typecode or data-type to which the array is cast.
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          Controls the memory layout order of the result.
 |          'C' means C order, 'F' means Fortran order, 'A'
 |          means 'F' order if all the arrays are Fortran contiguous,
 |          'C' order otherwise, and 'K' means as close to the
 |          order the array elements appear in memory as possible.
 |          Default is 'K'.
 |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
 |          Controls what kind of data casting may occur. Defaults to 'unsafe'
 |          for backwards compatibility.
 |      
 |            * 'no' means the data types should not be cast at all.
 |            * 'equiv' means only byte-order changes are allowed.
 |            * 'safe' means only casts which can preserve values are allowed.
 |            * 'same_kind' means only safe casts or casts within a kind,
 |              like float64 to float32, are allowed.
 |            * 'unsafe' means any data conversions may be done.
 |      subok : bool, optional
 |          If True, then sub-classes will be passed-through (default), otherwise
 |          the returned array will be forced to be a base-class array.
 |      copy : bool, optional
 |          By default, astype always returns a newly allocated array. If this
 |          is set to false, and the `dtype`, `order`, and `subok`
 |          requirements are satisfied, the input array is returned instead
 |          of a copy.
 |      
 |      Returns
 |      -------
 |      arr_t : ndarray
 |          Unless `copy` is False and the other conditions for returning the input
 |          array are satisfied (see description for `copy` input parameter), `arr_t`
 |          is a new array of the same shape as the input array, with dtype, order
 |          given by `dtype`, `order`.
 |      
 |      Notes
 |      -----
 |      Starting in NumPy 1.9, astype method now returns an error if the string
 |      dtype to cast to is not long enough in 'safe' casting mode to hold the max
 |      value of integer/float array that is being casted. Previously the casting
 |      was allowed even if the result was truncated.
 |      
 |      Raises
 |      ------
 |      ComplexWarning
 |          When casting from complex to float or int. To avoid this,
 |          one should use ``a.real.astype(t)``.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 2.5])
 |      >>> x
 |      array([ 1. ,  2. ,  2.5])
 |      
 |      >>> x.astype(int)
 |      array([1, 2, 2])
 |  
 |  byteswap(...)
 |      a.byteswap(inplace=False)
 |      
 |      Swap the bytes of the array elements
 |      
 |      Toggle between low-endian and big-endian data representation by
 |      returning a byteswapped array, optionally swapped in-place.
 |      
 |      Parameters
 |      ----------
 |      inplace : bool, optional
 |          If ``True``, swap bytes in-place, default is ``False``.
 |      
 |      Returns
 |      -------
 |      out : ndarray
 |          The byteswapped array. If `inplace` is ``True``, this is
 |          a view to self.
 |      
 |      Examples
 |      --------
 |      >>> A = np.array([1, 256, 8755], dtype=np.int16)
 |      >>> map(hex, A)
 |      ['0x1', '0x100', '0x2233']
 |      >>> A.byteswap(inplace=True)
 |      array([  256,     1, 13090], dtype=int16)
 |      >>> map(hex, A)
 |      ['0x100', '0x1', '0x3322']
 |      
 |      Arrays of strings are not swapped
 |      
 |      >>> A = np.array(['ceg', 'fac'])
 |      >>> A.byteswap()
 |      array(['ceg', 'fac'],
 |            dtype='|S3')
 |  
 |  choose(...)
 |      a.choose(choices, out=None, mode='raise')
 |      
 |      Use an index array to construct a new array from a set of choices.
 |      
 |      Refer to `numpy.choose` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.choose : equivalent function
 |  
 |  clip(...)
 |      a.clip(min=None, max=None, out=None)
 |      
 |      Return an array whose values are limited to ``[min, max]``.
 |      One of max or min must be given.
 |      
 |      Refer to `numpy.clip` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.clip : equivalent function
 |  
 |  compress(...)
 |      a.compress(condition, axis=None, out=None)
 |      
 |      Return selected slices of this array along given axis.
 |      
 |      Refer to `numpy.compress` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.compress : equivalent function
 |  
 |  conj(...)
 |      a.conj()
 |      
 |      Complex-conjugate all elements.
 |      
 |      Refer to `numpy.conjugate` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.conjugate : equivalent function
 |  
 |  conjugate(...)
 |      a.conjugate()
 |      
 |      Return the complex conjugate, element-wise.
 |      
 |      Refer to `numpy.conjugate` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.conjugate : equivalent function
 |  
 |  copy(...)
 |      a.copy(order='C')
 |      
 |      Return a copy of the array.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          Controls the memory layout of the copy. 'C' means C-order,
 |          'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
 |          'C' otherwise. 'K' means match the layout of `a` as closely
 |          as possible. (Note that this function and :func:`numpy.copy` are very
 |          similar, but have different default values for their order=
 |          arguments.)
 |      
 |      See also
 |      --------
 |      numpy.copy
 |      numpy.copyto
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[1,2,3],[4,5,6]], order='F')
 |      
 |      >>> y = x.copy()
 |      
 |      >>> x.fill(0)
 |      
 |      >>> x
 |      array([[0, 0, 0],
 |             [0, 0, 0]])
 |      
 |      >>> y
 |      array([[1, 2, 3],
 |             [4, 5, 6]])
 |      
 |      >>> y.flags['C_CONTIGUOUS']
 |      True
 |  
 |  cumprod(...)
 |      a.cumprod(axis=None, dtype=None, out=None)
 |      
 |      Return the cumulative product of the elements along the given axis.
 |      
 |      Refer to `numpy.cumprod` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.cumprod : equivalent function
 |  
 |  cumsum(...)
 |      a.cumsum(axis=None, dtype=None, out=None)
 |      
 |      Return the cumulative sum of the elements along the given axis.
 |      
 |      Refer to `numpy.cumsum` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.cumsum : equivalent function
 |  
 |  diagonal(...)
 |      a.diagonal(offset=0, axis1=0, axis2=1)
 |      
 |      Return specified diagonals. In NumPy 1.9 the returned array is a
 |      read-only view instead of a copy as in previous NumPy versions.  In
 |      a future version the read-only restriction will be removed.
 |      
 |      Refer to :func:`numpy.diagonal` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.diagonal : equivalent function
 |  
 |  dot(...)
 |      a.dot(b, out=None)
 |      
 |      Dot product of two arrays.
 |      
 |      Refer to `numpy.dot` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.dot : equivalent function
 |      
 |      Examples
 |      --------
 |      >>> a = np.eye(2)
 |      >>> b = np.ones((2, 2)) * 2
 |      >>> a.dot(b)
 |      array([[ 2.,  2.],
 |             [ 2.,  2.]])
 |      
 |      This array method can be conveniently chained:
 |      
 |      >>> a.dot(b).dot(b)
 |      array([[ 8.,  8.],
 |             [ 8.,  8.]])
 |  
 |  dump(...)
 |      a.dump(file)
 |      
 |      Dump a pickle of the array to the specified file.
 |      The array can be read back with pickle.load or numpy.load.
 |      
 |      Parameters
 |      ----------
 |      file : str
 |          A string naming the dump file.
 |  
 |  dumps(...)
 |      a.dumps()
 |      
 |      Returns the pickle of the array as a string.
 |      pickle.loads or numpy.loads will convert the string back to an array.
 |      
 |      Parameters
 |      ----------
 |      None
 |  
 |  fill(...)
 |      a.fill(value)
 |      
 |      Fill the array with a scalar value.
 |      
 |      Parameters
 |      ----------
 |      value : scalar
 |          All elements of `a` will be assigned this value.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([1, 2])
 |      >>> a.fill(0)
 |      >>> a
 |      array([0, 0])
 |      >>> a = np.empty(2)
 |      >>> a.fill(1)
 |      >>> a
 |      array([ 1.,  1.])
 |  
 |  flatten(...)
 |      a.flatten(order='C')
 |      
 |      Return a copy of the array collapsed into one dimension.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          'C' means to flatten in row-major (C-style) order.
 |          'F' means to flatten in column-major (Fortran-
 |          style) order. 'A' means to flatten in column-major
 |          order if `a` is Fortran *contiguous* in memory,
 |          row-major order otherwise. 'K' means to flatten
 |          `a` in the order the elements occur in memory.
 |          The default is 'C'.
 |      
 |      Returns
 |      -------
 |      y : ndarray
 |          A copy of the input array, flattened to one dimension.
 |      
 |      See Also
 |      --------
 |      ravel : Return a flattened array.
 |      flat : A 1-D flat iterator over the array.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1,2], [3,4]])
 |      >>> a.flatten()
 |      array([1, 2, 3, 4])
 |      >>> a.flatten('F')
 |      array([1, 3, 2, 4])
 |  
 |  getfield(...)
 |      a.getfield(dtype, offset=0)
 |      
 |      Returns a field of the given array as a certain type.
 |      
 |      A field is a view of the array data with a given data-type. The values in
 |      the view are determined by the given type and the offset into the current
 |      array in bytes. The offset needs to be such that the view dtype fits in the
 |      array dtype; for example an array of dtype complex128 has 16-byte elements.
 |      If taking a view with a 32-bit integer (4 bytes), the offset needs to be
 |      between 0 and 12 bytes.
 |      
 |      Parameters
 |      ----------
 |      dtype : str or dtype
 |          The data type of the view. The dtype size of the view can not be larger
 |          than that of the array itself.
 |      offset : int
 |          Number of bytes to skip before beginning the element view.
 |      
 |      Examples
 |      --------
 |      >>> x = np.diag([1.+1.j]*2)
 |      >>> x[1, 1] = 2 + 4.j
 |      >>> x
 |      array([[ 1.+1.j,  0.+0.j],
 |             [ 0.+0.j,  2.+4.j]])
 |      >>> x.getfield(np.float64)
 |      array([[ 1.,  0.],
 |             [ 0.,  2.]])
 |      
 |      By choosing an offset of 8 bytes we can select the complex part of the
 |      array for our view:
 |      
 |      >>> x.getfield(np.float64, offset=8)
 |      array([[ 1.,  0.],
 |         [ 0.,  4.]])
 |  
 |  item(...)
 |      a.item(*args)
 |      
 |      Copy an element of an array to a standard Python scalar and return it.
 |      
 |      Parameters
 |      ----------
 |      \*args : Arguments (variable number and type)
 |      
 |          * none: in this case, the method only works for arrays
 |            with one element (`a.size == 1`), which element is
 |            copied into a standard Python scalar object and returned.
 |      
 |          * int_type: this argument is interpreted as a flat index into
 |            the array, specifying which element to copy and return.
 |      
 |          * tuple of int_types: functions as does a single int_type argument,
 |            except that the argument is interpreted as an nd-index into the
 |            array.
 |      
 |      Returns
 |      -------
 |      z : Standard Python scalar object
 |          A copy of the specified element of the array as a suitable
 |          Python scalar
 |      
 |      Notes
 |      -----
 |      When the data type of `a` is longdouble or clongdouble, item() returns
 |      a scalar array object because there is no available Python scalar that
 |      would not lose information. Void arrays return a buffer object for item(),
 |      unless fields are defined, in which case a tuple is returned.
 |      
 |      `item` is very similar to a[args], except, instead of an array scalar,
 |      a standard Python scalar is returned. This can be useful for speeding up
 |      access to elements of the array and doing arithmetic on elements of the
 |      array using Python's optimized math.
 |      
 |      Examples
 |      --------
 |      >>> x = np.random.randint(9, size=(3, 3))
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 8, 3],
 |             [8, 5, 3]])
 |      >>> x.item(3)
 |      2
 |      >>> x.item(7)
 |      5
 |      >>> x.item((0, 1))
 |      1
 |      >>> x.item((2, 2))
 |      3
 |  
 |  itemset(...)
 |      a.itemset(*args)
 |      
 |      Insert scalar into an array (scalar is cast to array's dtype, if possible)
 |      
 |      There must be at least 1 argument, and define the last argument
 |      as *item*.  Then, ``a.itemset(*args)`` is equivalent to but faster
 |      than ``a[args] = item``.  The item should be a scalar value and `args`
 |      must select a single item in the array `a`.
 |      
 |      Parameters
 |      ----------
 |      \*args : Arguments
 |          If one argument: a scalar, only used in case `a` is of size 1.
 |          If two arguments: the last argument is the value to be set
 |          and must be a scalar, the first argument specifies a single array
 |          element location. It is either an int or a tuple.
 |      
 |      Notes
 |      -----
 |      Compared to indexing syntax, `itemset` provides some speed increase
 |      for placing a scalar into a particular location in an `ndarray`,
 |      if you must do this.  However, generally this is discouraged:
 |      among other problems, it complicates the appearance of the code.
 |      Also, when using `itemset` (and `item`) inside a loop, be sure
 |      to assign the methods to a local variable to avoid the attribute
 |      look-up at each loop iteration.
 |      
 |      Examples
 |      --------
 |      >>> x = np.random.randint(9, size=(3, 3))
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 8, 3],
 |             [8, 5, 3]])
 |      >>> x.itemset(4, 0)
 |      >>> x.itemset((2, 2), 9)
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 0, 3],
 |             [8, 5, 9]])
 |  
 |  max(...)
 |      a.max(axis=None, out=None, keepdims=False)
 |      
 |      Return the maximum along a given axis.
 |      
 |      Refer to `numpy.amax` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.amax : equivalent function
 |  
 |  mean(...)
 |      a.mean(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Returns the average of the array elements along given axis.
 |      
 |      Refer to `numpy.mean` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.mean : equivalent function
 |  
 |  min(...)
 |      a.min(axis=None, out=None, keepdims=False)
 |      
 |      Return the minimum along a given axis.
 |      
 |      Refer to `numpy.amin` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.amin : equivalent function
 |  
 |  newbyteorder(...)
 |      arr.newbyteorder(new_order='S')
 |      
 |      Return the array with the same data viewed with a different byte order.
 |      
 |      Equivalent to::
 |      
 |          arr.view(arr.dtype.newbytorder(new_order))
 |      
 |      Changes are also made in all fields and sub-arrays of the array data
 |      type.
 |      
 |      
 |      
 |      Parameters
 |      ----------
 |      new_order : string, optional
 |          Byte order to force; a value from the byte order specifications
 |          below. `new_order` codes can be any of:
 |      
 |          * 'S' - swap dtype from current to opposite endian
 |          * {'<', 'L'} - little endian
 |          * {'>', 'B'} - big endian
 |          * {'=', 'N'} - native order
 |          * {'|', 'I'} - ignore (no change to byte order)
 |      
 |          The default value ('S') results in swapping the current
 |          byte order. The code does a case-insensitive check on the first
 |          letter of `new_order` for the alternatives above.  For example,
 |          any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 |      
 |      
 |      Returns
 |      -------
 |      new_arr : array
 |          New array object with the dtype reflecting given change to the
 |          byte order.
 |  
 |  nonzero(...)
 |      a.nonzero()
 |      
 |      Return the indices of the elements that are non-zero.
 |      
 |      Refer to `numpy.nonzero` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.nonzero : equivalent function
 |  
 |  partition(...)
 |      a.partition(kth, axis=-1, kind='introselect', order=None)
 |      
 |      Rearranges the elements in the array in such a way that value of the
 |      element in kth position is in the position it would be in a sorted array.
 |      All elements smaller than the kth element are moved before this element and
 |      all equal or greater are moved behind it. The ordering of the elements in
 |      the two partitions is undefined.
 |      
 |      .. versionadded:: 1.8.0
 |      
 |      Parameters
 |      ----------
 |      kth : int or sequence of ints
 |          Element index to partition by. The kth element value will be in its
 |          final sorted position and all smaller elements will be moved before it
 |          and all equal or greater elements behind it.
 |          The order all elements in the partitions is undefined.
 |          If provided with a sequence of kth it will partition all elements
 |          indexed by kth of them into their sorted position at once.
 |      axis : int, optional
 |          Axis along which to sort. Default is -1, which means sort along the
 |          last axis.
 |      kind : {'introselect'}, optional
 |          Selection algorithm. Default is 'introselect'.
 |      order : str or list of str, optional
 |          When `a` is an array with fields defined, this argument specifies
 |          which fields to compare first, second, etc.  A single field can
 |          be specified as a string, and not all fields need be specified,
 |          but unspecified fields will still be used, in the order in which
 |          they come up in the dtype, to break ties.
 |      
 |      See Also
 |      --------
 |      numpy.partition : Return a parititioned copy of an array.
 |      argpartition : Indirect partition.
 |      sort : Full sort.
 |      
 |      Notes
 |      -----
 |      See ``np.partition`` for notes on the different algorithms.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([3, 4, 2, 1])
 |      >>> a.partition(3)
 |      >>> a
 |      array([2, 1, 3, 4])
 |      
 |      >>> a.partition((1, 3))
 |      array([1, 2, 3, 4])
 |  
 |  prod(...)
 |      a.prod(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Return the product of the array elements over the given axis
 |      
 |      Refer to `numpy.prod` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.prod : equivalent function
 |  
 |  ptp(...)
 |      a.ptp(axis=None, out=None)
 |      
 |      Peak to peak (maximum - minimum) value along a given axis.
 |      
 |      Refer to `numpy.ptp` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.ptp : equivalent function
 |  
 |  put(...)
 |      a.put(indices, values, mode='raise')
 |      
 |      Set ``a.flat[n] = values[n]`` for all `n` in indices.
 |      
 |      Refer to `numpy.put` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.put : equivalent function
 |  
 |  ravel(...)
 |      a.ravel([order])
 |      
 |      Return a flattened array.
 |      
 |      Refer to `numpy.ravel` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.ravel : equivalent function
 |      
 |      ndarray.flat : a flat iterator on the array.
 |  
 |  repeat(...)
 |      a.repeat(repeats, axis=None)
 |      
 |      Repeat elements of an array.
 |      
 |      Refer to `numpy.repeat` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.repeat : equivalent function
 |  
 |  reshape(...)
 |      a.reshape(shape, order='C')
 |      
 |      Returns an array containing the same data with a new shape.
 |      
 |      Refer to `numpy.reshape` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.reshape : equivalent function
 |      
 |      Notes
 |      -----
 |      Unlike the free function `numpy.reshape`, this method on `ndarray` allows
 |      the elements of the shape parameter to be passed in as separate arguments.
 |      For example, ``a.reshape(10, 11)`` is equivalent to
 |      ``a.reshape((10, 11))``.
 |  
 |  resize(...)
 |      a.resize(new_shape, refcheck=True)
 |      
 |      Change shape and size of array in-place.
 |      
 |      Parameters
 |      ----------
 |      new_shape : tuple of ints, or `n` ints
 |          Shape of resized array.
 |      refcheck : bool, optional
 |          If False, reference count will not be checked. Default is True.
 |      
 |      Returns
 |      -------
 |      None
 |      
 |      Raises
 |      ------
 |      ValueError
 |          If `a` does not own its own data or references or views to it exist,
 |          and the data memory must be changed.
 |          PyPy only: will always raise if the data memory must be changed, since
 |          there is no reliable way to determine if references or views to it
 |          exist.
 |      
 |      SystemError
 |          If the `order` keyword argument is specified. This behaviour is a
 |          bug in NumPy.
 |      
 |      See Also
 |      --------
 |      resize : Return a new array with the specified shape.
 |      
 |      Notes
 |      -----
 |      This reallocates space for the data area if necessary.
 |      
 |      Only contiguous arrays (data elements consecutive in memory) can be
 |      resized.
 |      
 |      The purpose of the reference count check is to make sure you
 |      do not use this array as a buffer for another Python object and then
 |      reallocate the memory. However, reference counts can increase in
 |      other ways so if you are sure that you have not shared the memory
 |      for this array with another Python object, then you may safely set
 |      `refcheck` to False.
 |      
 |      Examples
 |      --------
 |      Shrinking an array: array is flattened (in the order that the data are
 |      stored in memory), resized, and reshaped:
 |      
 |      >>> a = np.array([[0, 1], [2, 3]], order='C')
 |      >>> a.resize((2, 1))
 |      >>> a
 |      array([[0],
 |             [1]])
 |      
 |      >>> a = np.array([[0, 1], [2, 3]], order='F')
 |      >>> a.resize((2, 1))
 |      >>> a
 |      array([[0],
 |             [2]])
 |      
 |      Enlarging an array: as above, but missing entries are filled with zeros:
 |      
 |      >>> b = np.array([[0, 1], [2, 3]])
 |      >>> b.resize(2, 3) # new_shape parameter doesn't have to be a tuple
 |      >>> b
 |      array([[0, 1, 2],
 |             [3, 0, 0]])
 |      
 |      Referencing an array prevents resizing...
 |      
 |      >>> c = a
 |      >>> a.resize((1, 1))
 |      Traceback (most recent call last):
 |      ...
 |      ValueError: cannot resize an array that has been referenced ...
 |      
 |      Unless `refcheck` is False:
 |      
 |      >>> a.resize((1, 1), refcheck=False)
 |      >>> a
 |      array([[0]])
 |      >>> c
 |      array([[0]])
 |  
 |  round(...)
 |      a.round(decimals=0, out=None)
 |      
 |      Return `a` with each element rounded to the given number of decimals.
 |      
 |      Refer to `numpy.around` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.around : equivalent function
 |  
 |  searchsorted(...)
 |      a.searchsorted(v, side='left', sorter=None)
 |      
 |      Find indices where elements of v should be inserted in a to maintain order.
 |      
 |      For full documentation, see `numpy.searchsorted`
 |      
 |      See Also
 |      --------
 |      numpy.searchsorted : equivalent function
 |  
 |  setfield(...)
 |      a.setfield(val, dtype, offset=0)
 |      
 |      Put a value into a specified place in a field defined by a data-type.
 |      
 |      Place `val` into `a`'s field defined by `dtype` and beginning `offset`
 |      bytes into the field.
 |      
 |      Parameters
 |      ----------
 |      val : object
 |          Value to be placed in field.
 |      dtype : dtype object
 |          Data-type of the field in which to place `val`.
 |      offset : int, optional
 |          The number of bytes into the field at which to place `val`.
 |      
 |      Returns
 |      -------
 |      None
 |      
 |      See Also
 |      --------
 |      getfield
 |      
 |      Examples
 |      --------
 |      >>> x = np.eye(3)
 |      >>> x.getfield(np.float64)
 |      array([[ 1.,  0.,  0.],
 |             [ 0.,  1.,  0.],
 |             [ 0.,  0.,  1.]])
 |      >>> x.setfield(3, np.int32)
 |      >>> x.getfield(np.int32)
 |      array([[3, 3, 3],
 |             [3, 3, 3],
 |             [3, 3, 3]])
 |      >>> x
 |      array([[  1.00000000e+000,   1.48219694e-323,   1.48219694e-323],
 |             [  1.48219694e-323,   1.00000000e+000,   1.48219694e-323],
 |             [  1.48219694e-323,   1.48219694e-323,   1.00000000e+000]])
 |      >>> x.setfield(np.eye(3), np.int32)
 |      >>> x
 |      array([[ 1.,  0.,  0.],
 |             [ 0.,  1.,  0.],
 |             [ 0.,  0.,  1.]])
 |  
 |  setflags(...)
 |      a.setflags(write=None, align=None, uic=None)
 |      
 |      Set array flags WRITEABLE, ALIGNED, (WRITEBACKIFCOPY and UPDATEIFCOPY),
 |      respectively.
 |      
 |      These Boolean-valued flags affect how numpy interprets the memory
 |      area used by `a` (see Notes below). The ALIGNED flag can only
 |      be set to True if the data is actually aligned according to the type.
 |      The WRITEBACKIFCOPY and (deprecated) UPDATEIFCOPY flags can never be set
 |      to True. The flag WRITEABLE can only be set to True if the array owns its
 |      own memory, or the ultimate owner of the memory exposes a writeable buffer
 |      interface, or is a string. (The exception for string is made so that
 |      unpickling can be done without copying memory.)
 |      
 |      Parameters
 |      ----------
 |      write : bool, optional
 |          Describes whether or not `a` can be written to.
 |      align : bool, optional
 |          Describes whether or not `a` is aligned properly for its type.
 |      uic : bool, optional
 |          Describes whether or not `a` is a copy of another ""base"" array.
 |      
 |      Notes
 |      -----
 |      Array flags provide information about how the memory area used
 |      for the array is to be interpreted. There are 7 Boolean flags
 |      in use, only four of which can be changed by the user:
 |      WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED.
 |      
 |      WRITEABLE (W) the data area can be written to;
 |      
 |      ALIGNED (A) the data and strides are aligned appropriately for the hardware
 |      (as determined by the compiler);
 |      
 |      UPDATEIFCOPY (U) (deprecated), replaced by WRITEBACKIFCOPY;
 |      
 |      WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced
 |      by .base). When the C-API function PyArray_ResolveWritebackIfCopy is
 |      called, the base array will be updated with the contents of this array.
 |      
 |      All flags can be accessed using the single (upper case) letter as well
 |      as the full name.
 |      
 |      Examples
 |      --------
 |      >>> y
 |      array([[3, 1, 7],
 |             [2, 0, 0],
 |             [8, 5, 9]])
 |      >>> y.flags
 |        C_CONTIGUOUS : True
 |        F_CONTIGUOUS : False
 |        OWNDATA : True
 |        WRITEABLE : True
 |        ALIGNED : True
 |        WRITEBACKIFCOPY : False
 |        UPDATEIFCOPY : False
 |      >>> y.setflags(write=0, align=0)
 |      >>> y.flags
 |        C_CONTIGUOUS : True
 |        F_CONTIGUOUS : False
 |        OWNDATA : True
 |        WRITEABLE : False
 |        ALIGNED : False
 |        WRITEBACKIFCOPY : False
 |        UPDATEIFCOPY : False
 |      >>> y.setflags(uic=1)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: cannot set WRITEBACKIFCOPY flag to True
 |  
 |  sort(...)
 |      a.sort(axis=-1, kind='quicksort', order=None)
 |      
 |      Sort an array, in-place.
 |      
 |      Parameters
 |      ----------
 |      axis : int, optional
 |          Axis along which to sort. Default is -1, which means sort along the
 |          last axis.
 |      kind : {'quicksort', 'mergesort', 'heapsort'}, optional
 |          Sorting algorithm. Default is 'quicksort'.
 |      order : str or list of str, optional
 |          When `a` is an array with fields defined, this argument specifies
 |          which fields to compare first, second, etc.  A single field can
 |          be specified as a string, and not all fields need be specified,
 |          but unspecified fields will still be used, in the order in which
 |          they come up in the dtype, to break ties.
 |      
 |      See Also
 |      --------
 |      numpy.sort : Return a sorted copy of an array.
 |      argsort : Indirect sort.
 |      lexsort : Indirect stable sort on multiple keys.
 |      searchsorted : Find elements in sorted array.
 |      partition: Partial sort.
 |      
 |      Notes
 |      -----
 |      See ``sort`` for notes on the different sorting algorithms.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1,4], [3,1]])
 |      >>> a.sort(axis=1)
 |      >>> a
 |      array([[1, 4],
 |             [1, 3]])
 |      >>> a.sort(axis=0)
 |      >>> a
 |      array([[1, 3],
 |             [1, 4]])
 |      
 |      Use the `order` keyword to specify a field to use when sorting a
 |      structured array:
 |      
 |      >>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])
 |      >>> a.sort(order='y')
 |      >>> a
 |      array([('c', 1), ('a', 2)],
 |            dtype=[('x', '|S1'), ('y', '<i4')])
 |  
 |  squeeze(...)
 |      a.squeeze(axis=None)
 |      
 |      Remove single-dimensional entries from the shape of `a`.
 |      
 |      Refer to `numpy.squeeze` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.squeeze : equivalent function
 |  
 |  std(...)
 |      a.std(axis=None, dtype=None, out=None, ddof=0, keepdims=False)
 |      
 |      Returns the standard deviation of the array elements along given axis.
 |      
 |      Refer to `numpy.std` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.std : equivalent function
 |  
 |  sum(...)
 |      a.sum(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Return the sum of the array elements over the given axis.
 |      
 |      Refer to `numpy.sum` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.sum : equivalent function
 |  
 |  swapaxes(...)
 |      a.swapaxes(axis1, axis2)
 |      
 |      Return a view of the array with `axis1` and `axis2` interchanged.
 |      
 |      Refer to `numpy.swapaxes` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.swapaxes : equivalent function
 |  
 |  take(...)
 |      a.take(indices, axis=None, out=None, mode='raise')
 |      
 |      Return an array formed from the elements of `a` at the given indices.
 |      
 |      Refer to `numpy.take` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.take : equivalent function
 |  
 |  tobytes(...)
 |      a.tobytes(order='C')
 |      
 |      Construct Python bytes containing the raw data bytes in the array.
 |      
 |      Constructs Python bytes showing a copy of the raw contents of
 |      data memory. The bytes object can be produced in either 'C' or 'Fortran',
 |      or 'Any' order (the default is 'C'-order). 'Any' order means C-order
 |      unless the F_CONTIGUOUS flag in the array is set, in which case it
 |      means 'Fortran' order.
 |      
 |      .. versionadded:: 1.9.0
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', None}, optional
 |          Order of the data for multidimensional arrays:
 |          C, Fortran, or the same as for the original array.
 |      
 |      Returns
 |      -------
 |      s : bytes
 |          Python bytes exhibiting a copy of `a`'s raw data.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[0, 1], [2, 3]])
 |      >>> x.tobytes()
 |      b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
 |      >>> x.tobytes('C') == x.tobytes()
 |      True
 |      >>> x.tobytes('F')
 |      b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
 |  
 |  tofile(...)
 |      a.tofile(fid, sep="""", format=""%s"")
 |      
 |      Write array to a file as text or binary (default).
 |      
 |      Data is always written in 'C' order, independent of the order of `a`.
 |      The data produced by this method can be recovered using the function
 |      fromfile().
 |      
 |      Parameters
 |      ----------
 |      fid : file or str
 |          An open file object, or a string containing a filename.
 |      sep : str
 |          Separator between array items for text output.
 |          If """" (empty), a binary file is written, equivalent to
 |          ``file.write(a.tobytes())``.
 |      format : str
 |          Format string for text file output.
 |          Each entry in the array is formatted to text by first converting
 |          it to the closest Python type, and then using ""format"" % item.
 |      
 |      Notes
 |      -----
 |      This is a convenience function for quick storage of array data.
 |      Information on endianness and precision is lost, so this method is not a
 |      good choice for files intended to archive data or transport data between
 |      machines with different endianness. Some of these problems can be overcome
 |      by outputting the data as text files, at the expense of speed and file
 |      size.
 |  
 |  tolist(...)
 |      a.tolist()
 |      
 |      Return the array as a (possibly nested) list.
 |      
 |      Return a copy of the array data as a (nested) Python list.
 |      Data items are converted to the nearest compatible Python type.
 |      
 |      Parameters
 |      ----------
 |      none
 |      
 |      Returns
 |      -------
 |      y : list
 |          The possibly nested list of array elements.
 |      
 |      Notes
 |      -----
 |      The array may be recreated, ``a = np.array(a.tolist())``.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([1, 2])
 |      >>> a.tolist()
 |      [1, 2]
 |      >>> a = np.array([[1, 2], [3, 4]])
 |      >>> list(a)
 |      [array([1, 2]), array([3, 4])]
 |      >>> a.tolist()
 |      [[1, 2], [3, 4]]
 |  
 |  tostring(...)
 |      a.tostring(order='C')
 |      
 |      Construct Python bytes containing the raw data bytes in the array.
 |      
 |      Constructs Python bytes showing a copy of the raw contents of
 |      data memory. The bytes object can be produced in either 'C' or 'Fortran',
 |      or 'Any' order (the default is 'C'-order). 'Any' order means C-order
 |      unless the F_CONTIGUOUS flag in the array is set, in which case it
 |      means 'Fortran' order.
 |      
 |      This function is a compatibility alias for tobytes. Despite its name it returns bytes not strings.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', None}, optional
 |          Order of the data for multidimensional arrays:
 |          C, Fortran, or the same as for the original array.
 |      
 |      Returns
 |      -------
 |      s : bytes
 |          Python bytes exhibiting a copy of `a`'s raw data.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[0, 1], [2, 3]])
 |      >>> x.tobytes()
 |      b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
 |      >>> x.tobytes('C') == x.tobytes()
 |      True
 |      >>> x.tobytes('F')
 |      b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
 |  
 |  trace(...)
 |      a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)
 |      
 |      Return the sum along diagonals of the array.
 |      
 |      Refer to `numpy.trace` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.trace : equivalent function
 |  
 |  transpose(...)
 |      a.transpose(*axes)
 |      
 |      Returns a view of the array with axes transposed.
 |      
 |      For a 1-D array, this has no effect. (To change between column and
 |      row vectors, first cast the 1-D array into a matrix object.)
 |      For a 2-D array, this is the usual matrix transpose.
 |      For an n-D array, if axes are given, their order indicates how the
 |      axes are permuted (see Examples). If axes are not provided and
 |      ``a.shape = (i[0], i[1], ... i[n-2], i[n-1])``, then
 |      ``a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0])``.
 |      
 |      Parameters
 |      ----------
 |      axes : None, tuple of ints, or `n` ints
 |      
 |       * None or no argument: reverses the order of the axes.
 |      
 |       * tuple of ints: `i` in the `j`-th place in the tuple means `a`'s
 |         `i`-th axis becomes `a.transpose()`'s `j`-th axis.
 |      
 |       * `n` ints: same as an n-tuple of the same ints (this form is
 |         intended simply as a ""convenience"" alternative to the tuple form)
 |      
 |      Returns
 |      -------
 |      out : ndarray
 |          View of `a`, with axes suitably permuted.
 |      
 |      See Also
 |      --------
 |      ndarray.T : Array property returning the array transposed.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1, 2], [3, 4]])
 |      >>> a
 |      array([[1, 2],
 |             [3, 4]])
 |      >>> a.transpose()
 |      array([[1, 3],
 |             [2, 4]])
 |      >>> a.transpose((1, 0))
 |      array([[1, 3],
 |             [2, 4]])
 |      >>> a.transpose(1, 0)
 |      array([[1, 3],
 |             [2, 4]])
 |  
 |  var(...)
 |      a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False)
 |      
 |      Returns the variance of the array elements, along given axis.
 |      
 |      Refer to `numpy.var` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.var : equivalent function
 |  
 |  view(...)
 |      a.view(dtype=None, type=None)
 |      
 |      New view of array with the same data.
 |      
 |      Parameters
 |      ----------
 |      dtype : data-type or ndarray sub-class, optional
 |          Data-type descriptor of the returned view, e.g., float32 or int16. The
 |          default, None, results in the view having the same data-type as `a`.
 |          This argument can also be specified as an ndarray sub-class, which
 |          then specifies the type of the returned object (this is equivalent to
 |          setting the ``type`` parameter).
 |      type : Python type, optional
 |          Type of the returned view, e.g., ndarray or matrix.  Again, the
 |          default None results in type preservation.
 |      
 |      Notes
 |      -----
 |      ``a.view()`` is used two different ways:
 |      
 |      ``a.view(some_dtype)`` or ``a.view(dtype=some_dtype)`` constructs a view
 |      of the array's memory with a different data-type.  This can cause a
 |      reinterpretation of the bytes of memory.
 |      
 |      ``a.view(ndarray_subclass)`` or ``a.view(type=ndarray_subclass)`` just
 |      returns an instance of `ndarray_subclass` that looks at the same array
 |      (same shape, dtype, etc.)  This does not cause a reinterpretation of the
 |      memory.
 |      
 |      For ``a.view(some_dtype)``, if ``some_dtype`` has a different number of
 |      bytes per entry than the previous dtype (for example, converting a
 |      regular array to a structured array), then the behavior of the view
 |      cannot be predicted just from the superficial appearance of ``a`` (shown
 |      by ``print(a)``). It also depends on exactly how ``a`` is stored in
 |      memory. Therefore if ``a`` is C-ordered versus fortran-ordered, versus
 |      defined as a slice or transpose, etc., the view may give different
 |      results.
 |      
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])
 |      
 |      Viewing array data using a different type and dtype:
 |      
 |      >>> y = x.view(dtype=np.int16, type=np.matrix)
 |      >>> y
 |      matrix([[513]], dtype=int16)
 |      >>> print(type(y))
 |      <class 'numpy.matrixlib.defmatrix.matrix'>
 |      
 |      Creating a view on a structured array so it can be used in calculations
 |      
 |      >>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)])
 |      >>> xv = x.view(dtype=np.int8).reshape(-1,2)
 |      >>> xv
 |      array([[1, 2],
 |             [3, 4]], dtype=int8)
 |      >>> xv.mean(0)
 |      array([ 2.,  3.])
 |      
 |      Making changes to the view changes the underlying array
 |      
 |      >>> xv[0,1] = 20
 |      >>> print(x)
 |      [(1, 20) (3, 4)]
 |      
 |      Using a view to convert an array to a recarray:
 |      
 |      >>> z = x.view(np.recarray)
 |      >>> z.a
 |      array([1], dtype=int8)
 |      
 |      Views share data:
 |      
 |      >>> x[0] = (9, 10)
 |      >>> z[0]
 |      (9, 10)
 |      
 |      Views that change the dtype size (bytes per entry) should normally be
 |      avoided on arrays defined by slices, transposes, fortran-ordering, etc.:
 |      
 |      >>> x = np.array([[1,2,3],[4,5,6]], dtype=np.int16)
 |      >>> y = x[:, 0:2]
 |      >>> y
 |      array([[1, 2],
 |             [4, 5]], dtype=int16)
 |      >>> y.view(dtype=[('width', np.int16), ('length', np.int16)])
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: new type not compatible with array.
 |      >>> z = y.copy()
 |      >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
 |      array([[(1, 2)],
 |             [(4, 5)]], dtype=[('width', '<i2'), ('length', '<i2')])
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from numpy.ndarray:
 |  
 |  T
 |      Same as self.transpose(), except that self is returned if
 |      self.ndim < 2.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[1.,2.],[3.,4.]])
 |      >>> x
 |      array([[ 1.,  2.],
 |             [ 3.,  4.]])
 |      >>> x.T
 |      array([[ 1.,  3.],
 |             [ 2.,  4.]])
 |      >>> x = np.array([1.,2.,3.,4.])
 |      >>> x
 |      array([ 1.,  2.,  3.,  4.])
 |      >>> x.T
 |      array([ 1.,  2.,  3.,  4.])
 |  
 |  __array_finalize__
 |      None.
 |  
 |  __array_interface__
 |      Array protocol: Python side.
 |  
 |  __array_priority__
 |      Array priority.
 |  
 |  __array_struct__
 |      Array protocol: C-struct side.
 |  
 |  base
 |      Base object if memory is from some other object.
 |      
 |      Examples
 |      --------
 |      The base of an array that owns its memory is None:
 |      
 |      >>> x = np.array([1,2,3,4])
 |      >>> x.base is None
 |      True
 |      
 |      Slicing creates a view, whose memory is shared with x:
 |      
 |      >>> y = x[2:]
 |      >>> y.base is x
 |      True
 |  
 |  ctypes
 |      An object to simplify the interaction of the array with the ctypes
 |      module.
 |      
 |      This attribute creates an object that makes it easier to use arrays
 |      when calling shared libraries with the ctypes module. The returned
 |      object has, among others, data, shape, and strides attributes (see
 |      Notes below) which themselves return ctypes objects that can be used
 |      as arguments to a shared library.
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      c : Python object
 |          Possessing attributes data, shape, strides, etc.
 |      
 |      See Also
 |      --------
 |      numpy.ctypeslib
 |      
 |      Notes
 |      -----
 |      Below are the public attributes of this object which were documented
 |      in ""Guide to NumPy"" (we have omitted undocumented public attributes,
 |      as well as documented private attributes):
 |      
 |      * data: A pointer to the memory area of the array as a Python integer.
 |        This memory area may contain data that is not aligned, or not in correct
 |        byte-order. The memory area may not even be writeable. The array
 |        flags and data-type of this array should be respected when passing this
 |        attribute to arbitrary C-code to avoid trouble that can include Python
 |        crashing. User Beware! The value of this attribute is exactly the same
 |        as self._array_interface_['data'][0].
 |      
 |      * shape (c_intp*self.ndim): A ctypes array of length self.ndim where
 |        the basetype is the C-integer corresponding to dtype('p') on this
 |        platform. This base-type could be c_int, c_long, or c_longlong
 |        depending on the platform. The c_intp type is defined accordingly in
 |        numpy.ctypeslib. The ctypes array contains the shape of the underlying
 |        array.
 |      
 |      * strides (c_intp*self.ndim): A ctypes array of length self.ndim where
 |        the basetype is the same as for the shape attribute. This ctypes array
 |        contains the strides information from the underlying array. This strides
 |        information is important for showing how many bytes must be jumped to
 |        get to the next element in the array.
 |      
 |      * data_as(obj): Return the data pointer cast to a particular c-types object.
 |        For example, calling self._as_parameter_ is equivalent to
 |        self.data_as(ctypes.c_void_p). Perhaps you want to use the data as a
 |        pointer to a ctypes array of floating-point data:
 |        self.data_as(ctypes.POINTER(ctypes.c_double)).
 |      
 |      * shape_as(obj): Return the shape tuple as an array of some other c-types
 |        type. For example: self.shape_as(ctypes.c_short).
 |      
 |      * strides_as(obj): Return the strides tuple as an array of some other
 |        c-types type. For example: self.strides_as(ctypes.c_longlong).
 |      
 |      Be careful using the ctypes attribute - especially on temporary
 |      arrays or arrays constructed on the fly. For example, calling
 |      ``(a+b).ctypes.data_as(ctypes.c_void_p)`` returns a pointer to memory
 |      that is invalid because the array created as (a+b) is deallocated
 |      before the next Python statement. You can avoid this problem using
 |      either ``c=a+b`` or ``ct=(a+b).ctypes``. In the latter case, ct will
 |      hold a reference to the array until ct is deleted or re-assigned.
 |      
 |      If the ctypes module is not available, then the ctypes attribute
 |      of array objects still returns something useful, but ctypes objects
 |      are not returned and errors may be raised instead. In particular,
 |      the object will still have the as parameter attribute which will
 |      return an integer equal to the data attribute.
 |      
 |      Examples
 |      --------
 |      >>> import ctypes
 |      >>> x
 |      array([[0, 1],
 |             [2, 3]])
 |      >>> x.ctypes.data
 |      30439712
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long))
 |      <ctypes.LP_c_long object at 0x01F01300>
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)).contents
 |      c_long(0)
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_longlong)).contents
 |      c_longlong(4294967296L)
 |      >>> x.ctypes.shape
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FFD580>
 |      >>> x.ctypes.shape_as(ctypes.c_long)
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
 |      >>> x.ctypes.strides
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
 |      >>> x.ctypes.strides_as(ctypes.c_longlong)
 |      <numpy.core._internal.c_longlong_Array_2 object at 0x01F01300>
 |  
 |  data
 |      Python buffer object pointing to the start of the array's data.
 |  
 |  dtype
 |      Data-type of the array's elements.
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      d : numpy dtype object
 |      
 |      See Also
 |      --------
 |      numpy.dtype
 |      
 |      Examples
 |      --------
 |      >>> x
 |      array([[0, 1],
 |             [2, 3]])
 |      >>> x.dtype
 |      dtype('int32')
 |      >>> type(x.dtype)
 |      <type 'numpy.dtype'>
 |  
 |  flags
 |      Information about the memory layout of the array.
 |      
 |      Attributes
 |      ----------
 |      C_CONTIGUOUS (C)
 |          The data is in a single, C-style contiguous segment.
 |      F_CONTIGUOUS (F)
 |          The data is in a single, Fortran-style contiguous segment.
 |      OWNDATA (O)
 |          The array owns the memory it uses or borrows it from another object.
 |      WRITEABLE (W)
 |          The data area can be written to.  Setting this to False locks
 |          the data, making it read-only.  A view (slice, etc.) inherits WRITEABLE
 |          from its base array at creation time, but a view of a writeable
 |          array may be subsequently locked while the base array remains writeable.
 |          (The opposite is not true, in that a view of a locked array may not
 |          be made writeable.  However, currently, locking a base object does not
 |          lock any views that already reference it, so under that circumstance it
 |          is possible to alter the contents of a locked array via a previously
 |          created writeable view onto it.)  Attempting to change a non-writeable
 |          array raises a RuntimeError exception.
 |      ALIGNED (A)
 |          The data and all elements are aligned appropriately for the hardware.
 |      WRITEBACKIFCOPY (X)
 |          This array is a copy of some other array. The C-API function
 |          PyArray_ResolveWritebackIfCopy must be called before deallocating
 |          to the base array will be updated with the contents of this array.
 |      UPDATEIFCOPY (U)
 |          (Deprecated, use WRITEBACKIFCOPY) This array is a copy of some other array.
 |          When this array is
 |          deallocated, the base array will be updated with the contents of
 |          this array.
 |      FNC
 |          F_CONTIGUOUS and not C_CONTIGUOUS.
 |      FORC
 |          F_CONTIGUOUS or C_CONTIGUOUS (one-segment test).
 |      BEHAVED (B)
 |          ALIGNED and WRITEABLE.
 |      CARRAY (CA)
 |          BEHAVED and C_CONTIGUOUS.
 |      FARRAY (FA)
 |          BEHAVED and F_CONTIGUOUS and not C_CONTIGUOUS.
 |      
 |      Notes
 |      -----
 |      The `flags` object can be accessed dictionary-like (as in ``a.flags['WRITEABLE']``),
 |      or by using lowercased attribute names (as in ``a.flags.writeable``). Short flag
 |      names are only supported in dictionary access.
 |      
 |      Only the WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED flags can be
 |      changed by the user, via direct assignment to the attribute or dictionary
 |      entry, or by calling `ndarray.setflags`.
 |      
 |      The array flags cannot be set arbitrarily:
 |      
 |      - UPDATEIFCOPY can only be set ``False``.
 |      - WRITEBACKIFCOPY can only be set ``False``.
 |      - ALIGNED can only be set ``True`` if the data is truly aligned.
 |      - WRITEABLE can only be set ``True`` if the array owns its own memory
 |        or the ultimate owner of the memory exposes a writeable buffer
 |        interface or is a string.
 |      
 |      Arrays can be both C-style and Fortran-style contiguous simultaneously.
 |      This is clear for 1-dimensional arrays, but can also be true for higher
 |      dimensional arrays.
 |      
 |      Even for contiguous arrays a stride for a given dimension
 |      ``arr.strides[dim]`` may be *arbitrary* if ``arr.shape[dim] == 1``
 |      or the array has no elements.
 |      It does *not* generally hold that ``self.strides[-1] == self.itemsize``
 |      for C-style contiguous arrays or ``self.strides[0] == self.itemsize`` for
 |      Fortran-style contiguous arrays is true.
 |  
 |  flat
 |      A 1-D iterator over the array.
 |      
 |      This is a `numpy.flatiter` instance, which acts similarly to, but is not
 |      a subclass of, Python's built-in iterator object.
 |      
 |      See Also
 |      --------
 |      flatten : Return a copy of the array collapsed into one dimension.
 |      
 |      flatiter
 |      
 |      Examples
 |      --------
 |      >>> x = np.arange(1, 7).reshape(2, 3)
 |      >>> x
 |      array([[1, 2, 3],
 |             [4, 5, 6]])
 |      >>> x.flat[3]
 |      4
 |      >>> x.T
 |      array([[1, 4],
 |             [2, 5],
 |             [3, 6]])
 |      >>> x.T.flat[3]
 |      5
 |      >>> type(x.flat)
 |      <type 'numpy.flatiter'>
 |      
 |      An assignment example:
 |      
 |      >>> x.flat = 3; x
 |      array([[3, 3, 3],
 |             [3, 3, 3]])
 |      >>> x.flat[[1,4]] = 1; x
 |      array([[3, 1, 3],
 |             [3, 1, 3]])
 |  
 |  imag
 |      The imaginary part of the array.
 |      
 |      Examples
 |      --------
 |      >>> x = np.sqrt([1+0j, 0+1j])
 |      >>> x.imag
 |      array([ 0.        ,  0.70710678])
 |      >>> x.imag.dtype
 |      dtype('float64')
 |  
 |  itemsize
 |      Length of one array element in bytes.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1,2,3], dtype=np.float64)
 |      >>> x.itemsize
 |      8
 |      >>> x = np.array([1,2,3], dtype=np.complex128)
 |      >>> x.itemsize
 |      16
 |  
 |  nbytes
 |      Total bytes consumed by the elements of the array.
 |      
 |      Notes
 |      -----
 |      Does not include memory consumed by non-element attributes of the
 |      array object.
 |      
 |      Examples
 |      --------
 |      >>> x = np.zeros((3,5,2), dtype=np.complex128)
 |      >>> x.nbytes
 |      480
 |      >>> np.prod(x.shape) * x.itemsize
 |      480
 |  
 |  ndim
 |      Number of array dimensions.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 3])
 |      >>> x.ndim
 |      1
 |      >>> y = np.zeros((2, 3, 4))
 |      >>> y.ndim
 |      3
 |  
 |  real
 |      The real part of the array.
 |      
 |      Examples
 |      --------
 |      >>> x = np.sqrt([1+0j, 0+1j])
 |      >>> x.real
 |      array([ 1.        ,  0.70710678])
 |      >>> x.real.dtype
 |      dtype('float64')
 |      
 |      See Also
 |      --------
 |      numpy.real : equivalent function
 |  
 |  shape
 |      Tuple of array dimensions.
 |      
 |      The shape property is usually used to get the current shape of an array,
 |      but may also be used to reshape the array in-place by assigning a tuple of
 |      array dimensions to it.  As with `numpy.reshape`, one of the new shape
 |      dimensions can be -1, in which case its value is inferred from the size of
 |      the array and the remaining dimensions. Reshaping an array in-place will
 |      fail if a copy is required.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 3, 4])
 |      >>> x.shape
 |      (4,)
 |      >>> y = np.zeros((2, 3, 4))
 |      >>> y.shape
 |      (2, 3, 4)
 |      >>> y.shape = (3, 8)
 |      >>> y
 |      array([[ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
 |             [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
 |             [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.]])
 |      >>> y.shape = (3, 6)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: total size of new array must be unchanged
 |      >>> np.zeros((4,2))[::2].shape = (-1,)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      AttributeError: incompatible shape for a non-contiguous array
 |      
 |      See Also
 |      --------
 |      numpy.reshape : similar function
 |      ndarray.reshape : similar method
 |  
 |  size
 |      Number of elements in the array.
 |      
 |      Equivalent to ``np.prod(a.shape)``, i.e., the product of the array's
 |      dimensions.
 |      
 |      Examples
 |      --------
 |      >>> x = np.zeros((3, 5, 2), dtype=np.complex128)
 |      >>> x.size
 |      30
 |      >>> np.prod(x.shape)
 |      30
 |  
 |  strides
 |      Tuple of bytes to step in each dimension when traversing an array.
 |      
 |      The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a`
 |      is::
 |      
 |          offset = sum(np.array(i) * a.strides)
 |      
 |      A more detailed explanation of strides can be found in the
 |      ""ndarray.rst"" file in the NumPy reference guide.
 |      
 |      Notes
 |      -----
 |      Imagine an array of 32-bit integers (each 4 bytes)::
 |      
 |        x = np.array([[0, 1, 2, 3, 4],
 |                      [5, 6, 7, 8, 9]], dtype=np.int32)
 |      
 |      This array is stored in memory as 40 bytes, one after the other
 |      (known as a contiguous block of memory).  The strides of an array tell
 |      us how many bytes we have to skip in memory to move to the next position
 |      along a certain axis.  For example, we have to skip 4 bytes (1 value) to
 |      move to the next column, but 20 bytes (5 values) to get to the same
 |      position in the next row.  As such, the strides for the array `x` will be
 |      ``(20, 4)``.
 |      
 |      See Also
 |      --------
 |      numpy.lib.stride_tricks.as_strided
 |      
 |      Examples
 |      --------
 |      >>> y = np.reshape(np.arange(2*3*4), (2,3,4))
 |      >>> y
 |      array([[[ 0,  1,  2,  3],
 |              [ 4,  5,  6,  7],
 |              [ 8,  9, 10, 11]],
 |             [[12, 13, 14, 15],
 |              [16, 17, 18, 19],
 |              [20, 21, 22, 23]]])
 |      >>> y.strides
 |      (48, 16, 4)
 |      >>> y[1,1,1]
 |      17
 |      >>> offset=sum(y.strides * np.array((1,1,1)))
 |      >>> offset/y.itemsize
 |      17
 |      
 |      >>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0)
 |      >>> x.strides
 |      (32, 4, 224, 1344)
 |      >>> i = np.array([3,5,2,2])
 |      >>> offset = sum(i * x.strides)
 |      >>> x[3,5,2,2]
 |      813
 |      >>> offset / x.itemsize
 |      813
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from numpy.ndarray:
 |  
 |  __hash__ = None
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.matlab.mio5.MatlabObject,io.matlab.mio5,MatlabObject,"Python Library Documentation: class MatlabObject in module scipy.io.matlab.mio5_params

class MatlabObject(numpy.ndarray)
 |  ndarray Subclass to contain matlab object
 |  
 |  Method resolution order:
 |      MatlabObject
 |      numpy.ndarray
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __array_finalize__(self, obj)
 |      None.
 |  
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |  
 |  __new__(cls, input_array, classname=None)
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from numpy.ndarray:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __array__(...)
 |      a.__array__(|dtype) -> reference if type unchanged, copy otherwise.
 |      
 |      Returns either a new reference to self if dtype is not given or a new array
 |      of provided data type if dtype is different from the current dtype of the
 |      array.
 |  
 |  __array_prepare__(...)
 |      a.__array_prepare__(obj) -> Object of same type as ndarray object obj.
 |  
 |  __array_ufunc__(...)
 |  
 |  __array_wrap__(...)
 |      a.__array_wrap__(obj) -> Object of same type as ndarray object a.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __complex__(...)
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __copy__(...)
 |      a.__copy__()
 |      
 |      Used if :func:`copy.copy` is called on an array. Returns a copy of the array.
 |      
 |      Equivalent to ``a.copy(order='K')``.
 |  
 |  __deepcopy__(...)
 |      a.__deepcopy__(memo, /) -> Deep copy of array.
 |      
 |      Used if :func:`copy.deepcopy` is called on an array.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __format__(...)
 |      default object formatter
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iadd__(self, value, /)
 |      Return self+=value.
 |  
 |  __iand__(self, value, /)
 |      Return self&=value.
 |  
 |  __ifloordiv__(self, value, /)
 |      Return self//=value.
 |  
 |  __ilshift__(self, value, /)
 |      Return self<<=value.
 |  
 |  __imatmul__(self, value, /)
 |      Return self@=value.
 |  
 |  __imod__(self, value, /)
 |      Return self%=value.
 |  
 |  __imul__(self, value, /)
 |      Return self*=value.
 |  
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __ior__(self, value, /)
 |      Return self|=value.
 |  
 |  __ipow__(self, value, /)
 |      Return self**=value.
 |  
 |  __irshift__(self, value, /)
 |      Return self>>=value.
 |  
 |  __isub__(self, value, /)
 |      Return self-=value.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __itruediv__(self, value, /)
 |      Return self/=value.
 |  
 |  __ixor__(self, value, /)
 |      Return self^=value.
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __matmul__(self, value, /)
 |      Return self@value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __reduce__(...)
 |      a.__reduce__()
 |      
 |      For pickling.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmatmul__(self, value, /)
 |      Return value@self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __setstate__(...)
 |      a.__setstate__(state, /)
 |      
 |      For unpickling.
 |      
 |      The `state` argument must be a sequence that contains the following
 |      elements:
 |      
 |      Parameters
 |      ----------
 |      version : int
 |          optional pickle version. If omitted defaults to 0.
 |      shape : tuple
 |      dtype : data-type
 |      isFortran : bool
 |      rawdata : string or list
 |          a binary string with the data (or a list if 'a' is an object array)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  all(...)
 |      a.all(axis=None, out=None, keepdims=False)
 |      
 |      Returns True if all elements evaluate to True.
 |      
 |      Refer to `numpy.all` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.all : equivalent function
 |  
 |  any(...)
 |      a.any(axis=None, out=None, keepdims=False)
 |      
 |      Returns True if any of the elements of `a` evaluate to True.
 |      
 |      Refer to `numpy.any` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.any : equivalent function
 |  
 |  argmax(...)
 |      a.argmax(axis=None, out=None)
 |      
 |      Return indices of the maximum values along the given axis.
 |      
 |      Refer to `numpy.argmax` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argmax : equivalent function
 |  
 |  argmin(...)
 |      a.argmin(axis=None, out=None)
 |      
 |      Return indices of the minimum values along the given axis of `a`.
 |      
 |      Refer to `numpy.argmin` for detailed documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argmin : equivalent function
 |  
 |  argpartition(...)
 |      a.argpartition(kth, axis=-1, kind='introselect', order=None)
 |      
 |      Returns the indices that would partition this array.
 |      
 |      Refer to `numpy.argpartition` for full documentation.
 |      
 |      .. versionadded:: 1.8.0
 |      
 |      See Also
 |      --------
 |      numpy.argpartition : equivalent function
 |  
 |  argsort(...)
 |      a.argsort(axis=-1, kind='quicksort', order=None)
 |      
 |      Returns the indices that would sort this array.
 |      
 |      Refer to `numpy.argsort` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argsort : equivalent function
 |  
 |  astype(...)
 |      a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)
 |      
 |      Copy of the array, cast to a specified type.
 |      
 |      Parameters
 |      ----------
 |      dtype : str or dtype
 |          Typecode or data-type to which the array is cast.
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          Controls the memory layout order of the result.
 |          'C' means C order, 'F' means Fortran order, 'A'
 |          means 'F' order if all the arrays are Fortran contiguous,
 |          'C' order otherwise, and 'K' means as close to the
 |          order the array elements appear in memory as possible.
 |          Default is 'K'.
 |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
 |          Controls what kind of data casting may occur. Defaults to 'unsafe'
 |          for backwards compatibility.
 |      
 |            * 'no' means the data types should not be cast at all.
 |            * 'equiv' means only byte-order changes are allowed.
 |            * 'safe' means only casts which can preserve values are allowed.
 |            * 'same_kind' means only safe casts or casts within a kind,
 |              like float64 to float32, are allowed.
 |            * 'unsafe' means any data conversions may be done.
 |      subok : bool, optional
 |          If True, then sub-classes will be passed-through (default), otherwise
 |          the returned array will be forced to be a base-class array.
 |      copy : bool, optional
 |          By default, astype always returns a newly allocated array. If this
 |          is set to false, and the `dtype`, `order`, and `subok`
 |          requirements are satisfied, the input array is returned instead
 |          of a copy.
 |      
 |      Returns
 |      -------
 |      arr_t : ndarray
 |          Unless `copy` is False and the other conditions for returning the input
 |          array are satisfied (see description for `copy` input parameter), `arr_t`
 |          is a new array of the same shape as the input array, with dtype, order
 |          given by `dtype`, `order`.
 |      
 |      Notes
 |      -----
 |      Starting in NumPy 1.9, astype method now returns an error if the string
 |      dtype to cast to is not long enough in 'safe' casting mode to hold the max
 |      value of integer/float array that is being casted. Previously the casting
 |      was allowed even if the result was truncated.
 |      
 |      Raises
 |      ------
 |      ComplexWarning
 |          When casting from complex to float or int. To avoid this,
 |          one should use ``a.real.astype(t)``.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 2.5])
 |      >>> x
 |      array([ 1. ,  2. ,  2.5])
 |      
 |      >>> x.astype(int)
 |      array([1, 2, 2])
 |  
 |  byteswap(...)
 |      a.byteswap(inplace=False)
 |      
 |      Swap the bytes of the array elements
 |      
 |      Toggle between low-endian and big-endian data representation by
 |      returning a byteswapped array, optionally swapped in-place.
 |      
 |      Parameters
 |      ----------
 |      inplace : bool, optional
 |          If ``True``, swap bytes in-place, default is ``False``.
 |      
 |      Returns
 |      -------
 |      out : ndarray
 |          The byteswapped array. If `inplace` is ``True``, this is
 |          a view to self.
 |      
 |      Examples
 |      --------
 |      >>> A = np.array([1, 256, 8755], dtype=np.int16)
 |      >>> map(hex, A)
 |      ['0x1', '0x100', '0x2233']
 |      >>> A.byteswap(inplace=True)
 |      array([  256,     1, 13090], dtype=int16)
 |      >>> map(hex, A)
 |      ['0x100', '0x1', '0x3322']
 |      
 |      Arrays of strings are not swapped
 |      
 |      >>> A = np.array(['ceg', 'fac'])
 |      >>> A.byteswap()
 |      array(['ceg', 'fac'],
 |            dtype='|S3')
 |  
 |  choose(...)
 |      a.choose(choices, out=None, mode='raise')
 |      
 |      Use an index array to construct a new array from a set of choices.
 |      
 |      Refer to `numpy.choose` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.choose : equivalent function
 |  
 |  clip(...)
 |      a.clip(min=None, max=None, out=None)
 |      
 |      Return an array whose values are limited to ``[min, max]``.
 |      One of max or min must be given.
 |      
 |      Refer to `numpy.clip` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.clip : equivalent function
 |  
 |  compress(...)
 |      a.compress(condition, axis=None, out=None)
 |      
 |      Return selected slices of this array along given axis.
 |      
 |      Refer to `numpy.compress` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.compress : equivalent function
 |  
 |  conj(...)
 |      a.conj()
 |      
 |      Complex-conjugate all elements.
 |      
 |      Refer to `numpy.conjugate` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.conjugate : equivalent function
 |  
 |  conjugate(...)
 |      a.conjugate()
 |      
 |      Return the complex conjugate, element-wise.
 |      
 |      Refer to `numpy.conjugate` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.conjugate : equivalent function
 |  
 |  copy(...)
 |      a.copy(order='C')
 |      
 |      Return a copy of the array.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          Controls the memory layout of the copy. 'C' means C-order,
 |          'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
 |          'C' otherwise. 'K' means match the layout of `a` as closely
 |          as possible. (Note that this function and :func:`numpy.copy` are very
 |          similar, but have different default values for their order=
 |          arguments.)
 |      
 |      See also
 |      --------
 |      numpy.copy
 |      numpy.copyto
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[1,2,3],[4,5,6]], order='F')
 |      
 |      >>> y = x.copy()
 |      
 |      >>> x.fill(0)
 |      
 |      >>> x
 |      array([[0, 0, 0],
 |             [0, 0, 0]])
 |      
 |      >>> y
 |      array([[1, 2, 3],
 |             [4, 5, 6]])
 |      
 |      >>> y.flags['C_CONTIGUOUS']
 |      True
 |  
 |  cumprod(...)
 |      a.cumprod(axis=None, dtype=None, out=None)
 |      
 |      Return the cumulative product of the elements along the given axis.
 |      
 |      Refer to `numpy.cumprod` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.cumprod : equivalent function
 |  
 |  cumsum(...)
 |      a.cumsum(axis=None, dtype=None, out=None)
 |      
 |      Return the cumulative sum of the elements along the given axis.
 |      
 |      Refer to `numpy.cumsum` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.cumsum : equivalent function
 |  
 |  diagonal(...)
 |      a.diagonal(offset=0, axis1=0, axis2=1)
 |      
 |      Return specified diagonals. In NumPy 1.9 the returned array is a
 |      read-only view instead of a copy as in previous NumPy versions.  In
 |      a future version the read-only restriction will be removed.
 |      
 |      Refer to :func:`numpy.diagonal` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.diagonal : equivalent function
 |  
 |  dot(...)
 |      a.dot(b, out=None)
 |      
 |      Dot product of two arrays.
 |      
 |      Refer to `numpy.dot` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.dot : equivalent function
 |      
 |      Examples
 |      --------
 |      >>> a = np.eye(2)
 |      >>> b = np.ones((2, 2)) * 2
 |      >>> a.dot(b)
 |      array([[ 2.,  2.],
 |             [ 2.,  2.]])
 |      
 |      This array method can be conveniently chained:
 |      
 |      >>> a.dot(b).dot(b)
 |      array([[ 8.,  8.],
 |             [ 8.,  8.]])
 |  
 |  dump(...)
 |      a.dump(file)
 |      
 |      Dump a pickle of the array to the specified file.
 |      The array can be read back with pickle.load or numpy.load.
 |      
 |      Parameters
 |      ----------
 |      file : str
 |          A string naming the dump file.
 |  
 |  dumps(...)
 |      a.dumps()
 |      
 |      Returns the pickle of the array as a string.
 |      pickle.loads or numpy.loads will convert the string back to an array.
 |      
 |      Parameters
 |      ----------
 |      None
 |  
 |  fill(...)
 |      a.fill(value)
 |      
 |      Fill the array with a scalar value.
 |      
 |      Parameters
 |      ----------
 |      value : scalar
 |          All elements of `a` will be assigned this value.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([1, 2])
 |      >>> a.fill(0)
 |      >>> a
 |      array([0, 0])
 |      >>> a = np.empty(2)
 |      >>> a.fill(1)
 |      >>> a
 |      array([ 1.,  1.])
 |  
 |  flatten(...)
 |      a.flatten(order='C')
 |      
 |      Return a copy of the array collapsed into one dimension.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          'C' means to flatten in row-major (C-style) order.
 |          'F' means to flatten in column-major (Fortran-
 |          style) order. 'A' means to flatten in column-major
 |          order if `a` is Fortran *contiguous* in memory,
 |          row-major order otherwise. 'K' means to flatten
 |          `a` in the order the elements occur in memory.
 |          The default is 'C'.
 |      
 |      Returns
 |      -------
 |      y : ndarray
 |          A copy of the input array, flattened to one dimension.
 |      
 |      See Also
 |      --------
 |      ravel : Return a flattened array.
 |      flat : A 1-D flat iterator over the array.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1,2], [3,4]])
 |      >>> a.flatten()
 |      array([1, 2, 3, 4])
 |      >>> a.flatten('F')
 |      array([1, 3, 2, 4])
 |  
 |  getfield(...)
 |      a.getfield(dtype, offset=0)
 |      
 |      Returns a field of the given array as a certain type.
 |      
 |      A field is a view of the array data with a given data-type. The values in
 |      the view are determined by the given type and the offset into the current
 |      array in bytes. The offset needs to be such that the view dtype fits in the
 |      array dtype; for example an array of dtype complex128 has 16-byte elements.
 |      If taking a view with a 32-bit integer (4 bytes), the offset needs to be
 |      between 0 and 12 bytes.
 |      
 |      Parameters
 |      ----------
 |      dtype : str or dtype
 |          The data type of the view. The dtype size of the view can not be larger
 |          than that of the array itself.
 |      offset : int
 |          Number of bytes to skip before beginning the element view.
 |      
 |      Examples
 |      --------
 |      >>> x = np.diag([1.+1.j]*2)
 |      >>> x[1, 1] = 2 + 4.j
 |      >>> x
 |      array([[ 1.+1.j,  0.+0.j],
 |             [ 0.+0.j,  2.+4.j]])
 |      >>> x.getfield(np.float64)
 |      array([[ 1.,  0.],
 |             [ 0.,  2.]])
 |      
 |      By choosing an offset of 8 bytes we can select the complex part of the
 |      array for our view:
 |      
 |      >>> x.getfield(np.float64, offset=8)
 |      array([[ 1.,  0.],
 |         [ 0.,  4.]])
 |  
 |  item(...)
 |      a.item(*args)
 |      
 |      Copy an element of an array to a standard Python scalar and return it.
 |      
 |      Parameters
 |      ----------
 |      \*args : Arguments (variable number and type)
 |      
 |          * none: in this case, the method only works for arrays
 |            with one element (`a.size == 1`), which element is
 |            copied into a standard Python scalar object and returned.
 |      
 |          * int_type: this argument is interpreted as a flat index into
 |            the array, specifying which element to copy and return.
 |      
 |          * tuple of int_types: functions as does a single int_type argument,
 |            except that the argument is interpreted as an nd-index into the
 |            array.
 |      
 |      Returns
 |      -------
 |      z : Standard Python scalar object
 |          A copy of the specified element of the array as a suitable
 |          Python scalar
 |      
 |      Notes
 |      -----
 |      When the data type of `a` is longdouble or clongdouble, item() returns
 |      a scalar array object because there is no available Python scalar that
 |      would not lose information. Void arrays return a buffer object for item(),
 |      unless fields are defined, in which case a tuple is returned.
 |      
 |      `item` is very similar to a[args], except, instead of an array scalar,
 |      a standard Python scalar is returned. This can be useful for speeding up
 |      access to elements of the array and doing arithmetic on elements of the
 |      array using Python's optimized math.
 |      
 |      Examples
 |      --------
 |      >>> x = np.random.randint(9, size=(3, 3))
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 8, 3],
 |             [8, 5, 3]])
 |      >>> x.item(3)
 |      2
 |      >>> x.item(7)
 |      5
 |      >>> x.item((0, 1))
 |      1
 |      >>> x.item((2, 2))
 |      3
 |  
 |  itemset(...)
 |      a.itemset(*args)
 |      
 |      Insert scalar into an array (scalar is cast to array's dtype, if possible)
 |      
 |      There must be at least 1 argument, and define the last argument
 |      as *item*.  Then, ``a.itemset(*args)`` is equivalent to but faster
 |      than ``a[args] = item``.  The item should be a scalar value and `args`
 |      must select a single item in the array `a`.
 |      
 |      Parameters
 |      ----------
 |      \*args : Arguments
 |          If one argument: a scalar, only used in case `a` is of size 1.
 |          If two arguments: the last argument is the value to be set
 |          and must be a scalar, the first argument specifies a single array
 |          element location. It is either an int or a tuple.
 |      
 |      Notes
 |      -----
 |      Compared to indexing syntax, `itemset` provides some speed increase
 |      for placing a scalar into a particular location in an `ndarray`,
 |      if you must do this.  However, generally this is discouraged:
 |      among other problems, it complicates the appearance of the code.
 |      Also, when using `itemset` (and `item`) inside a loop, be sure
 |      to assign the methods to a local variable to avoid the attribute
 |      look-up at each loop iteration.
 |      
 |      Examples
 |      --------
 |      >>> x = np.random.randint(9, size=(3, 3))
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 8, 3],
 |             [8, 5, 3]])
 |      >>> x.itemset(4, 0)
 |      >>> x.itemset((2, 2), 9)
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 0, 3],
 |             [8, 5, 9]])
 |  
 |  max(...)
 |      a.max(axis=None, out=None, keepdims=False)
 |      
 |      Return the maximum along a given axis.
 |      
 |      Refer to `numpy.amax` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.amax : equivalent function
 |  
 |  mean(...)
 |      a.mean(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Returns the average of the array elements along given axis.
 |      
 |      Refer to `numpy.mean` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.mean : equivalent function
 |  
 |  min(...)
 |      a.min(axis=None, out=None, keepdims=False)
 |      
 |      Return the minimum along a given axis.
 |      
 |      Refer to `numpy.amin` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.amin : equivalent function
 |  
 |  newbyteorder(...)
 |      arr.newbyteorder(new_order='S')
 |      
 |      Return the array with the same data viewed with a different byte order.
 |      
 |      Equivalent to::
 |      
 |          arr.view(arr.dtype.newbytorder(new_order))
 |      
 |      Changes are also made in all fields and sub-arrays of the array data
 |      type.
 |      
 |      
 |      
 |      Parameters
 |      ----------
 |      new_order : string, optional
 |          Byte order to force; a value from the byte order specifications
 |          below. `new_order` codes can be any of:
 |      
 |          * 'S' - swap dtype from current to opposite endian
 |          * {'<', 'L'} - little endian
 |          * {'>', 'B'} - big endian
 |          * {'=', 'N'} - native order
 |          * {'|', 'I'} - ignore (no change to byte order)
 |      
 |          The default value ('S') results in swapping the current
 |          byte order. The code does a case-insensitive check on the first
 |          letter of `new_order` for the alternatives above.  For example,
 |          any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 |      
 |      
 |      Returns
 |      -------
 |      new_arr : array
 |          New array object with the dtype reflecting given change to the
 |          byte order.
 |  
 |  nonzero(...)
 |      a.nonzero()
 |      
 |      Return the indices of the elements that are non-zero.
 |      
 |      Refer to `numpy.nonzero` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.nonzero : equivalent function
 |  
 |  partition(...)
 |      a.partition(kth, axis=-1, kind='introselect', order=None)
 |      
 |      Rearranges the elements in the array in such a way that value of the
 |      element in kth position is in the position it would be in a sorted array.
 |      All elements smaller than the kth element are moved before this element and
 |      all equal or greater are moved behind it. The ordering of the elements in
 |      the two partitions is undefined.
 |      
 |      .. versionadded:: 1.8.0
 |      
 |      Parameters
 |      ----------
 |      kth : int or sequence of ints
 |          Element index to partition by. The kth element value will be in its
 |          final sorted position and all smaller elements will be moved before it
 |          and all equal or greater elements behind it.
 |          The order all elements in the partitions is undefined.
 |          If provided with a sequence of kth it will partition all elements
 |          indexed by kth of them into their sorted position at once.
 |      axis : int, optional
 |          Axis along which to sort. Default is -1, which means sort along the
 |          last axis.
 |      kind : {'introselect'}, optional
 |          Selection algorithm. Default is 'introselect'.
 |      order : str or list of str, optional
 |          When `a` is an array with fields defined, this argument specifies
 |          which fields to compare first, second, etc.  A single field can
 |          be specified as a string, and not all fields need be specified,
 |          but unspecified fields will still be used, in the order in which
 |          they come up in the dtype, to break ties.
 |      
 |      See Also
 |      --------
 |      numpy.partition : Return a parititioned copy of an array.
 |      argpartition : Indirect partition.
 |      sort : Full sort.
 |      
 |      Notes
 |      -----
 |      See ``np.partition`` for notes on the different algorithms.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([3, 4, 2, 1])
 |      >>> a.partition(3)
 |      >>> a
 |      array([2, 1, 3, 4])
 |      
 |      >>> a.partition((1, 3))
 |      array([1, 2, 3, 4])
 |  
 |  prod(...)
 |      a.prod(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Return the product of the array elements over the given axis
 |      
 |      Refer to `numpy.prod` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.prod : equivalent function
 |  
 |  ptp(...)
 |      a.ptp(axis=None, out=None)
 |      
 |      Peak to peak (maximum - minimum) value along a given axis.
 |      
 |      Refer to `numpy.ptp` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.ptp : equivalent function
 |  
 |  put(...)
 |      a.put(indices, values, mode='raise')
 |      
 |      Set ``a.flat[n] = values[n]`` for all `n` in indices.
 |      
 |      Refer to `numpy.put` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.put : equivalent function
 |  
 |  ravel(...)
 |      a.ravel([order])
 |      
 |      Return a flattened array.
 |      
 |      Refer to `numpy.ravel` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.ravel : equivalent function
 |      
 |      ndarray.flat : a flat iterator on the array.
 |  
 |  repeat(...)
 |      a.repeat(repeats, axis=None)
 |      
 |      Repeat elements of an array.
 |      
 |      Refer to `numpy.repeat` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.repeat : equivalent function
 |  
 |  reshape(...)
 |      a.reshape(shape, order='C')
 |      
 |      Returns an array containing the same data with a new shape.
 |      
 |      Refer to `numpy.reshape` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.reshape : equivalent function
 |      
 |      Notes
 |      -----
 |      Unlike the free function `numpy.reshape`, this method on `ndarray` allows
 |      the elements of the shape parameter to be passed in as separate arguments.
 |      For example, ``a.reshape(10, 11)`` is equivalent to
 |      ``a.reshape((10, 11))``.
 |  
 |  resize(...)
 |      a.resize(new_shape, refcheck=True)
 |      
 |      Change shape and size of array in-place.
 |      
 |      Parameters
 |      ----------
 |      new_shape : tuple of ints, or `n` ints
 |          Shape of resized array.
 |      refcheck : bool, optional
 |          If False, reference count will not be checked. Default is True.
 |      
 |      Returns
 |      -------
 |      None
 |      
 |      Raises
 |      ------
 |      ValueError
 |          If `a` does not own its own data or references or views to it exist,
 |          and the data memory must be changed.
 |          PyPy only: will always raise if the data memory must be changed, since
 |          there is no reliable way to determine if references or views to it
 |          exist.
 |      
 |      SystemError
 |          If the `order` keyword argument is specified. This behaviour is a
 |          bug in NumPy.
 |      
 |      See Also
 |      --------
 |      resize : Return a new array with the specified shape.
 |      
 |      Notes
 |      -----
 |      This reallocates space for the data area if necessary.
 |      
 |      Only contiguous arrays (data elements consecutive in memory) can be
 |      resized.
 |      
 |      The purpose of the reference count check is to make sure you
 |      do not use this array as a buffer for another Python object and then
 |      reallocate the memory. However, reference counts can increase in
 |      other ways so if you are sure that you have not shared the memory
 |      for this array with another Python object, then you may safely set
 |      `refcheck` to False.
 |      
 |      Examples
 |      --------
 |      Shrinking an array: array is flattened (in the order that the data are
 |      stored in memory), resized, and reshaped:
 |      
 |      >>> a = np.array([[0, 1], [2, 3]], order='C')
 |      >>> a.resize((2, 1))
 |      >>> a
 |      array([[0],
 |             [1]])
 |      
 |      >>> a = np.array([[0, 1], [2, 3]], order='F')
 |      >>> a.resize((2, 1))
 |      >>> a
 |      array([[0],
 |             [2]])
 |      
 |      Enlarging an array: as above, but missing entries are filled with zeros:
 |      
 |      >>> b = np.array([[0, 1], [2, 3]])
 |      >>> b.resize(2, 3) # new_shape parameter doesn't have to be a tuple
 |      >>> b
 |      array([[0, 1, 2],
 |             [3, 0, 0]])
 |      
 |      Referencing an array prevents resizing...
 |      
 |      >>> c = a
 |      >>> a.resize((1, 1))
 |      Traceback (most recent call last):
 |      ...
 |      ValueError: cannot resize an array that has been referenced ...
 |      
 |      Unless `refcheck` is False:
 |      
 |      >>> a.resize((1, 1), refcheck=False)
 |      >>> a
 |      array([[0]])
 |      >>> c
 |      array([[0]])
 |  
 |  round(...)
 |      a.round(decimals=0, out=None)
 |      
 |      Return `a` with each element rounded to the given number of decimals.
 |      
 |      Refer to `numpy.around` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.around : equivalent function
 |  
 |  searchsorted(...)
 |      a.searchsorted(v, side='left', sorter=None)
 |      
 |      Find indices where elements of v should be inserted in a to maintain order.
 |      
 |      For full documentation, see `numpy.searchsorted`
 |      
 |      See Also
 |      --------
 |      numpy.searchsorted : equivalent function
 |  
 |  setfield(...)
 |      a.setfield(val, dtype, offset=0)
 |      
 |      Put a value into a specified place in a field defined by a data-type.
 |      
 |      Place `val` into `a`'s field defined by `dtype` and beginning `offset`
 |      bytes into the field.
 |      
 |      Parameters
 |      ----------
 |      val : object
 |          Value to be placed in field.
 |      dtype : dtype object
 |          Data-type of the field in which to place `val`.
 |      offset : int, optional
 |          The number of bytes into the field at which to place `val`.
 |      
 |      Returns
 |      -------
 |      None
 |      
 |      See Also
 |      --------
 |      getfield
 |      
 |      Examples
 |      --------
 |      >>> x = np.eye(3)
 |      >>> x.getfield(np.float64)
 |      array([[ 1.,  0.,  0.],
 |             [ 0.,  1.,  0.],
 |             [ 0.,  0.,  1.]])
 |      >>> x.setfield(3, np.int32)
 |      >>> x.getfield(np.int32)
 |      array([[3, 3, 3],
 |             [3, 3, 3],
 |             [3, 3, 3]])
 |      >>> x
 |      array([[  1.00000000e+000,   1.48219694e-323,   1.48219694e-323],
 |             [  1.48219694e-323,   1.00000000e+000,   1.48219694e-323],
 |             [  1.48219694e-323,   1.48219694e-323,   1.00000000e+000]])
 |      >>> x.setfield(np.eye(3), np.int32)
 |      >>> x
 |      array([[ 1.,  0.,  0.],
 |             [ 0.,  1.,  0.],
 |             [ 0.,  0.,  1.]])
 |  
 |  setflags(...)
 |      a.setflags(write=None, align=None, uic=None)
 |      
 |      Set array flags WRITEABLE, ALIGNED, (WRITEBACKIFCOPY and UPDATEIFCOPY),
 |      respectively.
 |      
 |      These Boolean-valued flags affect how numpy interprets the memory
 |      area used by `a` (see Notes below). The ALIGNED flag can only
 |      be set to True if the data is actually aligned according to the type.
 |      The WRITEBACKIFCOPY and (deprecated) UPDATEIFCOPY flags can never be set
 |      to True. The flag WRITEABLE can only be set to True if the array owns its
 |      own memory, or the ultimate owner of the memory exposes a writeable buffer
 |      interface, or is a string. (The exception for string is made so that
 |      unpickling can be done without copying memory.)
 |      
 |      Parameters
 |      ----------
 |      write : bool, optional
 |          Describes whether or not `a` can be written to.
 |      align : bool, optional
 |          Describes whether or not `a` is aligned properly for its type.
 |      uic : bool, optional
 |          Describes whether or not `a` is a copy of another ""base"" array.
 |      
 |      Notes
 |      -----
 |      Array flags provide information about how the memory area used
 |      for the array is to be interpreted. There are 7 Boolean flags
 |      in use, only four of which can be changed by the user:
 |      WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED.
 |      
 |      WRITEABLE (W) the data area can be written to;
 |      
 |      ALIGNED (A) the data and strides are aligned appropriately for the hardware
 |      (as determined by the compiler);
 |      
 |      UPDATEIFCOPY (U) (deprecated), replaced by WRITEBACKIFCOPY;
 |      
 |      WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced
 |      by .base). When the C-API function PyArray_ResolveWritebackIfCopy is
 |      called, the base array will be updated with the contents of this array.
 |      
 |      All flags can be accessed using the single (upper case) letter as well
 |      as the full name.
 |      
 |      Examples
 |      --------
 |      >>> y
 |      array([[3, 1, 7],
 |             [2, 0, 0],
 |             [8, 5, 9]])
 |      >>> y.flags
 |        C_CONTIGUOUS : True
 |        F_CONTIGUOUS : False
 |        OWNDATA : True
 |        WRITEABLE : True
 |        ALIGNED : True
 |        WRITEBACKIFCOPY : False
 |        UPDATEIFCOPY : False
 |      >>> y.setflags(write=0, align=0)
 |      >>> y.flags
 |        C_CONTIGUOUS : True
 |        F_CONTIGUOUS : False
 |        OWNDATA : True
 |        WRITEABLE : False
 |        ALIGNED : False
 |        WRITEBACKIFCOPY : False
 |        UPDATEIFCOPY : False
 |      >>> y.setflags(uic=1)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: cannot set WRITEBACKIFCOPY flag to True
 |  
 |  sort(...)
 |      a.sort(axis=-1, kind='quicksort', order=None)
 |      
 |      Sort an array, in-place.
 |      
 |      Parameters
 |      ----------
 |      axis : int, optional
 |          Axis along which to sort. Default is -1, which means sort along the
 |          last axis.
 |      kind : {'quicksort', 'mergesort', 'heapsort'}, optional
 |          Sorting algorithm. Default is 'quicksort'.
 |      order : str or list of str, optional
 |          When `a` is an array with fields defined, this argument specifies
 |          which fields to compare first, second, etc.  A single field can
 |          be specified as a string, and not all fields need be specified,
 |          but unspecified fields will still be used, in the order in which
 |          they come up in the dtype, to break ties.
 |      
 |      See Also
 |      --------
 |      numpy.sort : Return a sorted copy of an array.
 |      argsort : Indirect sort.
 |      lexsort : Indirect stable sort on multiple keys.
 |      searchsorted : Find elements in sorted array.
 |      partition: Partial sort.
 |      
 |      Notes
 |      -----
 |      See ``sort`` for notes on the different sorting algorithms.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1,4], [3,1]])
 |      >>> a.sort(axis=1)
 |      >>> a
 |      array([[1, 4],
 |             [1, 3]])
 |      >>> a.sort(axis=0)
 |      >>> a
 |      array([[1, 3],
 |             [1, 4]])
 |      
 |      Use the `order` keyword to specify a field to use when sorting a
 |      structured array:
 |      
 |      >>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])
 |      >>> a.sort(order='y')
 |      >>> a
 |      array([('c', 1), ('a', 2)],
 |            dtype=[('x', '|S1'), ('y', '<i4')])
 |  
 |  squeeze(...)
 |      a.squeeze(axis=None)
 |      
 |      Remove single-dimensional entries from the shape of `a`.
 |      
 |      Refer to `numpy.squeeze` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.squeeze : equivalent function
 |  
 |  std(...)
 |      a.std(axis=None, dtype=None, out=None, ddof=0, keepdims=False)
 |      
 |      Returns the standard deviation of the array elements along given axis.
 |      
 |      Refer to `numpy.std` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.std : equivalent function
 |  
 |  sum(...)
 |      a.sum(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Return the sum of the array elements over the given axis.
 |      
 |      Refer to `numpy.sum` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.sum : equivalent function
 |  
 |  swapaxes(...)
 |      a.swapaxes(axis1, axis2)
 |      
 |      Return a view of the array with `axis1` and `axis2` interchanged.
 |      
 |      Refer to `numpy.swapaxes` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.swapaxes : equivalent function
 |  
 |  take(...)
 |      a.take(indices, axis=None, out=None, mode='raise')
 |      
 |      Return an array formed from the elements of `a` at the given indices.
 |      
 |      Refer to `numpy.take` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.take : equivalent function
 |  
 |  tobytes(...)
 |      a.tobytes(order='C')
 |      
 |      Construct Python bytes containing the raw data bytes in the array.
 |      
 |      Constructs Python bytes showing a copy of the raw contents of
 |      data memory. The bytes object can be produced in either 'C' or 'Fortran',
 |      or 'Any' order (the default is 'C'-order). 'Any' order means C-order
 |      unless the F_CONTIGUOUS flag in the array is set, in which case it
 |      means 'Fortran' order.
 |      
 |      .. versionadded:: 1.9.0
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', None}, optional
 |          Order of the data for multidimensional arrays:
 |          C, Fortran, or the same as for the original array.
 |      
 |      Returns
 |      -------
 |      s : bytes
 |          Python bytes exhibiting a copy of `a`'s raw data.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[0, 1], [2, 3]])
 |      >>> x.tobytes()
 |      b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
 |      >>> x.tobytes('C') == x.tobytes()
 |      True
 |      >>> x.tobytes('F')
 |      b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
 |  
 |  tofile(...)
 |      a.tofile(fid, sep="""", format=""%s"")
 |      
 |      Write array to a file as text or binary (default).
 |      
 |      Data is always written in 'C' order, independent of the order of `a`.
 |      The data produced by this method can be recovered using the function
 |      fromfile().
 |      
 |      Parameters
 |      ----------
 |      fid : file or str
 |          An open file object, or a string containing a filename.
 |      sep : str
 |          Separator between array items for text output.
 |          If """" (empty), a binary file is written, equivalent to
 |          ``file.write(a.tobytes())``.
 |      format : str
 |          Format string for text file output.
 |          Each entry in the array is formatted to text by first converting
 |          it to the closest Python type, and then using ""format"" % item.
 |      
 |      Notes
 |      -----
 |      This is a convenience function for quick storage of array data.
 |      Information on endianness and precision is lost, so this method is not a
 |      good choice for files intended to archive data or transport data between
 |      machines with different endianness. Some of these problems can be overcome
 |      by outputting the data as text files, at the expense of speed and file
 |      size.
 |  
 |  tolist(...)
 |      a.tolist()
 |      
 |      Return the array as a (possibly nested) list.
 |      
 |      Return a copy of the array data as a (nested) Python list.
 |      Data items are converted to the nearest compatible Python type.
 |      
 |      Parameters
 |      ----------
 |      none
 |      
 |      Returns
 |      -------
 |      y : list
 |          The possibly nested list of array elements.
 |      
 |      Notes
 |      -----
 |      The array may be recreated, ``a = np.array(a.tolist())``.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([1, 2])
 |      >>> a.tolist()
 |      [1, 2]
 |      >>> a = np.array([[1, 2], [3, 4]])
 |      >>> list(a)
 |      [array([1, 2]), array([3, 4])]
 |      >>> a.tolist()
 |      [[1, 2], [3, 4]]
 |  
 |  tostring(...)
 |      a.tostring(order='C')
 |      
 |      Construct Python bytes containing the raw data bytes in the array.
 |      
 |      Constructs Python bytes showing a copy of the raw contents of
 |      data memory. The bytes object can be produced in either 'C' or 'Fortran',
 |      or 'Any' order (the default is 'C'-order). 'Any' order means C-order
 |      unless the F_CONTIGUOUS flag in the array is set, in which case it
 |      means 'Fortran' order.
 |      
 |      This function is a compatibility alias for tobytes. Despite its name it returns bytes not strings.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', None}, optional
 |          Order of the data for multidimensional arrays:
 |          C, Fortran, or the same as for the original array.
 |      
 |      Returns
 |      -------
 |      s : bytes
 |          Python bytes exhibiting a copy of `a`'s raw data.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[0, 1], [2, 3]])
 |      >>> x.tobytes()
 |      b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
 |      >>> x.tobytes('C') == x.tobytes()
 |      True
 |      >>> x.tobytes('F')
 |      b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
 |  
 |  trace(...)
 |      a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)
 |      
 |      Return the sum along diagonals of the array.
 |      
 |      Refer to `numpy.trace` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.trace : equivalent function
 |  
 |  transpose(...)
 |      a.transpose(*axes)
 |      
 |      Returns a view of the array with axes transposed.
 |      
 |      For a 1-D array, this has no effect. (To change between column and
 |      row vectors, first cast the 1-D array into a matrix object.)
 |      For a 2-D array, this is the usual matrix transpose.
 |      For an n-D array, if axes are given, their order indicates how the
 |      axes are permuted (see Examples). If axes are not provided and
 |      ``a.shape = (i[0], i[1], ... i[n-2], i[n-1])``, then
 |      ``a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0])``.
 |      
 |      Parameters
 |      ----------
 |      axes : None, tuple of ints, or `n` ints
 |      
 |       * None or no argument: reverses the order of the axes.
 |      
 |       * tuple of ints: `i` in the `j`-th place in the tuple means `a`'s
 |         `i`-th axis becomes `a.transpose()`'s `j`-th axis.
 |      
 |       * `n` ints: same as an n-tuple of the same ints (this form is
 |         intended simply as a ""convenience"" alternative to the tuple form)
 |      
 |      Returns
 |      -------
 |      out : ndarray
 |          View of `a`, with axes suitably permuted.
 |      
 |      See Also
 |      --------
 |      ndarray.T : Array property returning the array transposed.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1, 2], [3, 4]])
 |      >>> a
 |      array([[1, 2],
 |             [3, 4]])
 |      >>> a.transpose()
 |      array([[1, 3],
 |             [2, 4]])
 |      >>> a.transpose((1, 0))
 |      array([[1, 3],
 |             [2, 4]])
 |      >>> a.transpose(1, 0)
 |      array([[1, 3],
 |             [2, 4]])
 |  
 |  var(...)
 |      a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False)
 |      
 |      Returns the variance of the array elements, along given axis.
 |      
 |      Refer to `numpy.var` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.var : equivalent function
 |  
 |  view(...)
 |      a.view(dtype=None, type=None)
 |      
 |      New view of array with the same data.
 |      
 |      Parameters
 |      ----------
 |      dtype : data-type or ndarray sub-class, optional
 |          Data-type descriptor of the returned view, e.g., float32 or int16. The
 |          default, None, results in the view having the same data-type as `a`.
 |          This argument can also be specified as an ndarray sub-class, which
 |          then specifies the type of the returned object (this is equivalent to
 |          setting the ``type`` parameter).
 |      type : Python type, optional
 |          Type of the returned view, e.g., ndarray or matrix.  Again, the
 |          default None results in type preservation.
 |      
 |      Notes
 |      -----
 |      ``a.view()`` is used two different ways:
 |      
 |      ``a.view(some_dtype)`` or ``a.view(dtype=some_dtype)`` constructs a view
 |      of the array's memory with a different data-type.  This can cause a
 |      reinterpretation of the bytes of memory.
 |      
 |      ``a.view(ndarray_subclass)`` or ``a.view(type=ndarray_subclass)`` just
 |      returns an instance of `ndarray_subclass` that looks at the same array
 |      (same shape, dtype, etc.)  This does not cause a reinterpretation of the
 |      memory.
 |      
 |      For ``a.view(some_dtype)``, if ``some_dtype`` has a different number of
 |      bytes per entry than the previous dtype (for example, converting a
 |      regular array to a structured array), then the behavior of the view
 |      cannot be predicted just from the superficial appearance of ``a`` (shown
 |      by ``print(a)``). It also depends on exactly how ``a`` is stored in
 |      memory. Therefore if ``a`` is C-ordered versus fortran-ordered, versus
 |      defined as a slice or transpose, etc., the view may give different
 |      results.
 |      
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])
 |      
 |      Viewing array data using a different type and dtype:
 |      
 |      >>> y = x.view(dtype=np.int16, type=np.matrix)
 |      >>> y
 |      matrix([[513]], dtype=int16)
 |      >>> print(type(y))
 |      <class 'numpy.matrixlib.defmatrix.matrix'>
 |      
 |      Creating a view on a structured array so it can be used in calculations
 |      
 |      >>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)])
 |      >>> xv = x.view(dtype=np.int8).reshape(-1,2)
 |      >>> xv
 |      array([[1, 2],
 |             [3, 4]], dtype=int8)
 |      >>> xv.mean(0)
 |      array([ 2.,  3.])
 |      
 |      Making changes to the view changes the underlying array
 |      
 |      >>> xv[0,1] = 20
 |      >>> print(x)
 |      [(1, 20) (3, 4)]
 |      
 |      Using a view to convert an array to a recarray:
 |      
 |      >>> z = x.view(np.recarray)
 |      >>> z.a
 |      array([1], dtype=int8)
 |      
 |      Views share data:
 |      
 |      >>> x[0] = (9, 10)
 |      >>> z[0]
 |      (9, 10)
 |      
 |      Views that change the dtype size (bytes per entry) should normally be
 |      avoided on arrays defined by slices, transposes, fortran-ordering, etc.:
 |      
 |      >>> x = np.array([[1,2,3],[4,5,6]], dtype=np.int16)
 |      >>> y = x[:, 0:2]
 |      >>> y
 |      array([[1, 2],
 |             [4, 5]], dtype=int16)
 |      >>> y.view(dtype=[('width', np.int16), ('length', np.int16)])
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: new type not compatible with array.
 |      >>> z = y.copy()
 |      >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
 |      array([[(1, 2)],
 |             [(4, 5)]], dtype=[('width', '<i2'), ('length', '<i2')])
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from numpy.ndarray:
 |  
 |  T
 |      Same as self.transpose(), except that self is returned if
 |      self.ndim < 2.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[1.,2.],[3.,4.]])
 |      >>> x
 |      array([[ 1.,  2.],
 |             [ 3.,  4.]])
 |      >>> x.T
 |      array([[ 1.,  3.],
 |             [ 2.,  4.]])
 |      >>> x = np.array([1.,2.,3.,4.])
 |      >>> x
 |      array([ 1.,  2.,  3.,  4.])
 |      >>> x.T
 |      array([ 1.,  2.,  3.,  4.])
 |  
 |  __array_interface__
 |      Array protocol: Python side.
 |  
 |  __array_priority__
 |      Array priority.
 |  
 |  __array_struct__
 |      Array protocol: C-struct side.
 |  
 |  base
 |      Base object if memory is from some other object.
 |      
 |      Examples
 |      --------
 |      The base of an array that owns its memory is None:
 |      
 |      >>> x = np.array([1,2,3,4])
 |      >>> x.base is None
 |      True
 |      
 |      Slicing creates a view, whose memory is shared with x:
 |      
 |      >>> y = x[2:]
 |      >>> y.base is x
 |      True
 |  
 |  ctypes
 |      An object to simplify the interaction of the array with the ctypes
 |      module.
 |      
 |      This attribute creates an object that makes it easier to use arrays
 |      when calling shared libraries with the ctypes module. The returned
 |      object has, among others, data, shape, and strides attributes (see
 |      Notes below) which themselves return ctypes objects that can be used
 |      as arguments to a shared library.
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      c : Python object
 |          Possessing attributes data, shape, strides, etc.
 |      
 |      See Also
 |      --------
 |      numpy.ctypeslib
 |      
 |      Notes
 |      -----
 |      Below are the public attributes of this object which were documented
 |      in ""Guide to NumPy"" (we have omitted undocumented public attributes,
 |      as well as documented private attributes):
 |      
 |      * data: A pointer to the memory area of the array as a Python integer.
 |        This memory area may contain data that is not aligned, or not in correct
 |        byte-order. The memory area may not even be writeable. The array
 |        flags and data-type of this array should be respected when passing this
 |        attribute to arbitrary C-code to avoid trouble that can include Python
 |        crashing. User Beware! The value of this attribute is exactly the same
 |        as self._array_interface_['data'][0].
 |      
 |      * shape (c_intp*self.ndim): A ctypes array of length self.ndim where
 |        the basetype is the C-integer corresponding to dtype('p') on this
 |        platform. This base-type could be c_int, c_long, or c_longlong
 |        depending on the platform. The c_intp type is defined accordingly in
 |        numpy.ctypeslib. The ctypes array contains the shape of the underlying
 |        array.
 |      
 |      * strides (c_intp*self.ndim): A ctypes array of length self.ndim where
 |        the basetype is the same as for the shape attribute. This ctypes array
 |        contains the strides information from the underlying array. This strides
 |        information is important for showing how many bytes must be jumped to
 |        get to the next element in the array.
 |      
 |      * data_as(obj): Return the data pointer cast to a particular c-types object.
 |        For example, calling self._as_parameter_ is equivalent to
 |        self.data_as(ctypes.c_void_p). Perhaps you want to use the data as a
 |        pointer to a ctypes array of floating-point data:
 |        self.data_as(ctypes.POINTER(ctypes.c_double)).
 |      
 |      * shape_as(obj): Return the shape tuple as an array of some other c-types
 |        type. For example: self.shape_as(ctypes.c_short).
 |      
 |      * strides_as(obj): Return the strides tuple as an array of some other
 |        c-types type. For example: self.strides_as(ctypes.c_longlong).
 |      
 |      Be careful using the ctypes attribute - especially on temporary
 |      arrays or arrays constructed on the fly. For example, calling
 |      ``(a+b).ctypes.data_as(ctypes.c_void_p)`` returns a pointer to memory
 |      that is invalid because the array created as (a+b) is deallocated
 |      before the next Python statement. You can avoid this problem using
 |      either ``c=a+b`` or ``ct=(a+b).ctypes``. In the latter case, ct will
 |      hold a reference to the array until ct is deleted or re-assigned.
 |      
 |      If the ctypes module is not available, then the ctypes attribute
 |      of array objects still returns something useful, but ctypes objects
 |      are not returned and errors may be raised instead. In particular,
 |      the object will still have the as parameter attribute which will
 |      return an integer equal to the data attribute.
 |      
 |      Examples
 |      --------
 |      >>> import ctypes
 |      >>> x
 |      array([[0, 1],
 |             [2, 3]])
 |      >>> x.ctypes.data
 |      30439712
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long))
 |      <ctypes.LP_c_long object at 0x01F01300>
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)).contents
 |      c_long(0)
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_longlong)).contents
 |      c_longlong(4294967296L)
 |      >>> x.ctypes.shape
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FFD580>
 |      >>> x.ctypes.shape_as(ctypes.c_long)
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
 |      >>> x.ctypes.strides
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
 |      >>> x.ctypes.strides_as(ctypes.c_longlong)
 |      <numpy.core._internal.c_longlong_Array_2 object at 0x01F01300>
 |  
 |  data
 |      Python buffer object pointing to the start of the array's data.
 |  
 |  dtype
 |      Data-type of the array's elements.
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      d : numpy dtype object
 |      
 |      See Also
 |      --------
 |      numpy.dtype
 |      
 |      Examples
 |      --------
 |      >>> x
 |      array([[0, 1],
 |             [2, 3]])
 |      >>> x.dtype
 |      dtype('int32')
 |      >>> type(x.dtype)
 |      <type 'numpy.dtype'>
 |  
 |  flags
 |      Information about the memory layout of the array.
 |      
 |      Attributes
 |      ----------
 |      C_CONTIGUOUS (C)
 |          The data is in a single, C-style contiguous segment.
 |      F_CONTIGUOUS (F)
 |          The data is in a single, Fortran-style contiguous segment.
 |      OWNDATA (O)
 |          The array owns the memory it uses or borrows it from another object.
 |      WRITEABLE (W)
 |          The data area can be written to.  Setting this to False locks
 |          the data, making it read-only.  A view (slice, etc.) inherits WRITEABLE
 |          from its base array at creation time, but a view of a writeable
 |          array may be subsequently locked while the base array remains writeable.
 |          (The opposite is not true, in that a view of a locked array may not
 |          be made writeable.  However, currently, locking a base object does not
 |          lock any views that already reference it, so under that circumstance it
 |          is possible to alter the contents of a locked array via a previously
 |          created writeable view onto it.)  Attempting to change a non-writeable
 |          array raises a RuntimeError exception.
 |      ALIGNED (A)
 |          The data and all elements are aligned appropriately for the hardware.
 |      WRITEBACKIFCOPY (X)
 |          This array is a copy of some other array. The C-API function
 |          PyArray_ResolveWritebackIfCopy must be called before deallocating
 |          to the base array will be updated with the contents of this array.
 |      UPDATEIFCOPY (U)
 |          (Deprecated, use WRITEBACKIFCOPY) This array is a copy of some other array.
 |          When this array is
 |          deallocated, the base array will be updated with the contents of
 |          this array.
 |      FNC
 |          F_CONTIGUOUS and not C_CONTIGUOUS.
 |      FORC
 |          F_CONTIGUOUS or C_CONTIGUOUS (one-segment test).
 |      BEHAVED (B)
 |          ALIGNED and WRITEABLE.
 |      CARRAY (CA)
 |          BEHAVED and C_CONTIGUOUS.
 |      FARRAY (FA)
 |          BEHAVED and F_CONTIGUOUS and not C_CONTIGUOUS.
 |      
 |      Notes
 |      -----
 |      The `flags` object can be accessed dictionary-like (as in ``a.flags['WRITEABLE']``),
 |      or by using lowercased attribute names (as in ``a.flags.writeable``). Short flag
 |      names are only supported in dictionary access.
 |      
 |      Only the WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED flags can be
 |      changed by the user, via direct assignment to the attribute or dictionary
 |      entry, or by calling `ndarray.setflags`.
 |      
 |      The array flags cannot be set arbitrarily:
 |      
 |      - UPDATEIFCOPY can only be set ``False``.
 |      - WRITEBACKIFCOPY can only be set ``False``.
 |      - ALIGNED can only be set ``True`` if the data is truly aligned.
 |      - WRITEABLE can only be set ``True`` if the array owns its own memory
 |        or the ultimate owner of the memory exposes a writeable buffer
 |        interface or is a string.
 |      
 |      Arrays can be both C-style and Fortran-style contiguous simultaneously.
 |      This is clear for 1-dimensional arrays, but can also be true for higher
 |      dimensional arrays.
 |      
 |      Even for contiguous arrays a stride for a given dimension
 |      ``arr.strides[dim]`` may be *arbitrary* if ``arr.shape[dim] == 1``
 |      or the array has no elements.
 |      It does *not* generally hold that ``self.strides[-1] == self.itemsize``
 |      for C-style contiguous arrays or ``self.strides[0] == self.itemsize`` for
 |      Fortran-style contiguous arrays is true.
 |  
 |  flat
 |      A 1-D iterator over the array.
 |      
 |      This is a `numpy.flatiter` instance, which acts similarly to, but is not
 |      a subclass of, Python's built-in iterator object.
 |      
 |      See Also
 |      --------
 |      flatten : Return a copy of the array collapsed into one dimension.
 |      
 |      flatiter
 |      
 |      Examples
 |      --------
 |      >>> x = np.arange(1, 7).reshape(2, 3)
 |      >>> x
 |      array([[1, 2, 3],
 |             [4, 5, 6]])
 |      >>> x.flat[3]
 |      4
 |      >>> x.T
 |      array([[1, 4],
 |             [2, 5],
 |             [3, 6]])
 |      >>> x.T.flat[3]
 |      5
 |      >>> type(x.flat)
 |      <type 'numpy.flatiter'>
 |      
 |      An assignment example:
 |      
 |      >>> x.flat = 3; x
 |      array([[3, 3, 3],
 |             [3, 3, 3]])
 |      >>> x.flat[[1,4]] = 1; x
 |      array([[3, 1, 3],
 |             [3, 1, 3]])
 |  
 |  imag
 |      The imaginary part of the array.
 |      
 |      Examples
 |      --------
 |      >>> x = np.sqrt([1+0j, 0+1j])
 |      >>> x.imag
 |      array([ 0.        ,  0.70710678])
 |      >>> x.imag.dtype
 |      dtype('float64')
 |  
 |  itemsize
 |      Length of one array element in bytes.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1,2,3], dtype=np.float64)
 |      >>> x.itemsize
 |      8
 |      >>> x = np.array([1,2,3], dtype=np.complex128)
 |      >>> x.itemsize
 |      16
 |  
 |  nbytes
 |      Total bytes consumed by the elements of the array.
 |      
 |      Notes
 |      -----
 |      Does not include memory consumed by non-element attributes of the
 |      array object.
 |      
 |      Examples
 |      --------
 |      >>> x = np.zeros((3,5,2), dtype=np.complex128)
 |      >>> x.nbytes
 |      480
 |      >>> np.prod(x.shape) * x.itemsize
 |      480
 |  
 |  ndim
 |      Number of array dimensions.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 3])
 |      >>> x.ndim
 |      1
 |      >>> y = np.zeros((2, 3, 4))
 |      >>> y.ndim
 |      3
 |  
 |  real
 |      The real part of the array.
 |      
 |      Examples
 |      --------
 |      >>> x = np.sqrt([1+0j, 0+1j])
 |      >>> x.real
 |      array([ 1.        ,  0.70710678])
 |      >>> x.real.dtype
 |      dtype('float64')
 |      
 |      See Also
 |      --------
 |      numpy.real : equivalent function
 |  
 |  shape
 |      Tuple of array dimensions.
 |      
 |      The shape property is usually used to get the current shape of an array,
 |      but may also be used to reshape the array in-place by assigning a tuple of
 |      array dimensions to it.  As with `numpy.reshape`, one of the new shape
 |      dimensions can be -1, in which case its value is inferred from the size of
 |      the array and the remaining dimensions. Reshaping an array in-place will
 |      fail if a copy is required.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 3, 4])
 |      >>> x.shape
 |      (4,)
 |      >>> y = np.zeros((2, 3, 4))
 |      >>> y.shape
 |      (2, 3, 4)
 |      >>> y.shape = (3, 8)
 |      >>> y
 |      array([[ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
 |             [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
 |             [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.]])
 |      >>> y.shape = (3, 6)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: total size of new array must be unchanged
 |      >>> np.zeros((4,2))[::2].shape = (-1,)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      AttributeError: incompatible shape for a non-contiguous array
 |      
 |      See Also
 |      --------
 |      numpy.reshape : similar function
 |      ndarray.reshape : similar method
 |  
 |  size
 |      Number of elements in the array.
 |      
 |      Equivalent to ``np.prod(a.shape)``, i.e., the product of the array's
 |      dimensions.
 |      
 |      Examples
 |      --------
 |      >>> x = np.zeros((3, 5, 2), dtype=np.complex128)
 |      >>> x.size
 |      30
 |      >>> np.prod(x.shape)
 |      30
 |  
 |  strides
 |      Tuple of bytes to step in each dimension when traversing an array.
 |      
 |      The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a`
 |      is::
 |      
 |          offset = sum(np.array(i) * a.strides)
 |      
 |      A more detailed explanation of strides can be found in the
 |      ""ndarray.rst"" file in the NumPy reference guide.
 |      
 |      Notes
 |      -----
 |      Imagine an array of 32-bit integers (each 4 bytes)::
 |      
 |        x = np.array([[0, 1, 2, 3, 4],
 |                      [5, 6, 7, 8, 9]], dtype=np.int32)
 |      
 |      This array is stored in memory as 40 bytes, one after the other
 |      (known as a contiguous block of memory).  The strides of an array tell
 |      us how many bytes we have to skip in memory to move to the next position
 |      along a certain axis.  For example, we have to skip 4 bytes (1 value) to
 |      move to the next column, but 20 bytes (5 values) to get to the same
 |      position in the next row.  As such, the strides for the array `x` will be
 |      ``(20, 4)``.
 |      
 |      See Also
 |      --------
 |      numpy.lib.stride_tricks.as_strided
 |      
 |      Examples
 |      --------
 |      >>> y = np.reshape(np.arange(2*3*4), (2,3,4))
 |      >>> y
 |      array([[[ 0,  1,  2,  3],
 |              [ 4,  5,  6,  7],
 |              [ 8,  9, 10, 11]],
 |             [[12, 13, 14, 15],
 |              [16, 17, 18, 19],
 |              [20, 21, 22, 23]]])
 |      >>> y.strides
 |      (48, 16, 4)
 |      >>> y[1,1,1]
 |      17
 |      >>> offset=sum(y.strides * np.array((1,1,1)))
 |      >>> offset/y.itemsize
 |      17
 |      
 |      >>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0)
 |      >>> x.strides
 |      (32, 4, 224, 1344)
 |      >>> i = np.array([3,5,2,2])
 |      >>> offset = sum(i * x.strides)
 |      >>> x[3,5,2,2]
 |      813
 |      >>> offset / x.itemsize
 |      813
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from numpy.ndarray:
 |  
 |  __hash__ = None
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.matlab.mio5.MatlabObject,io.matlab.mio5,MatlabObject,"Python Library Documentation: class MatlabObject in module scipy.io.matlab.mio5_params

class MatlabObject(numpy.ndarray)
 |  ndarray Subclass to contain matlab object
 |  
 |  Method resolution order:
 |      MatlabObject
 |      numpy.ndarray
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __array_finalize__(self, obj)
 |      None.
 |  
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |  
 |  __new__(cls, input_array, classname=None)
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from numpy.ndarray:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __array__(...)
 |      a.__array__(|dtype) -> reference if type unchanged, copy otherwise.
 |      
 |      Returns either a new reference to self if dtype is not given or a new array
 |      of provided data type if dtype is different from the current dtype of the
 |      array.
 |  
 |  __array_prepare__(...)
 |      a.__array_prepare__(obj) -> Object of same type as ndarray object obj.
 |  
 |  __array_ufunc__(...)
 |  
 |  __array_wrap__(...)
 |      a.__array_wrap__(obj) -> Object of same type as ndarray object a.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __complex__(...)
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __copy__(...)
 |      a.__copy__()
 |      
 |      Used if :func:`copy.copy` is called on an array. Returns a copy of the array.
 |      
 |      Equivalent to ``a.copy(order='K')``.
 |  
 |  __deepcopy__(...)
 |      a.__deepcopy__(memo, /) -> Deep copy of array.
 |      
 |      Used if :func:`copy.deepcopy` is called on an array.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __format__(...)
 |      default object formatter
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iadd__(self, value, /)
 |      Return self+=value.
 |  
 |  __iand__(self, value, /)
 |      Return self&=value.
 |  
 |  __ifloordiv__(self, value, /)
 |      Return self//=value.
 |  
 |  __ilshift__(self, value, /)
 |      Return self<<=value.
 |  
 |  __imatmul__(self, value, /)
 |      Return self@=value.
 |  
 |  __imod__(self, value, /)
 |      Return self%=value.
 |  
 |  __imul__(self, value, /)
 |      Return self*=value.
 |  
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __ior__(self, value, /)
 |      Return self|=value.
 |  
 |  __ipow__(self, value, /)
 |      Return self**=value.
 |  
 |  __irshift__(self, value, /)
 |      Return self>>=value.
 |  
 |  __isub__(self, value, /)
 |      Return self-=value.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __itruediv__(self, value, /)
 |      Return self/=value.
 |  
 |  __ixor__(self, value, /)
 |      Return self^=value.
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __matmul__(self, value, /)
 |      Return self@value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __reduce__(...)
 |      a.__reduce__()
 |      
 |      For pickling.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmatmul__(self, value, /)
 |      Return value@self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __setstate__(...)
 |      a.__setstate__(state, /)
 |      
 |      For unpickling.
 |      
 |      The `state` argument must be a sequence that contains the following
 |      elements:
 |      
 |      Parameters
 |      ----------
 |      version : int
 |          optional pickle version. If omitted defaults to 0.
 |      shape : tuple
 |      dtype : data-type
 |      isFortran : bool
 |      rawdata : string or list
 |          a binary string with the data (or a list if 'a' is an object array)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  all(...)
 |      a.all(axis=None, out=None, keepdims=False)
 |      
 |      Returns True if all elements evaluate to True.
 |      
 |      Refer to `numpy.all` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.all : equivalent function
 |  
 |  any(...)
 |      a.any(axis=None, out=None, keepdims=False)
 |      
 |      Returns True if any of the elements of `a` evaluate to True.
 |      
 |      Refer to `numpy.any` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.any : equivalent function
 |  
 |  argmax(...)
 |      a.argmax(axis=None, out=None)
 |      
 |      Return indices of the maximum values along the given axis.
 |      
 |      Refer to `numpy.argmax` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argmax : equivalent function
 |  
 |  argmin(...)
 |      a.argmin(axis=None, out=None)
 |      
 |      Return indices of the minimum values along the given axis of `a`.
 |      
 |      Refer to `numpy.argmin` for detailed documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argmin : equivalent function
 |  
 |  argpartition(...)
 |      a.argpartition(kth, axis=-1, kind='introselect', order=None)
 |      
 |      Returns the indices that would partition this array.
 |      
 |      Refer to `numpy.argpartition` for full documentation.
 |      
 |      .. versionadded:: 1.8.0
 |      
 |      See Also
 |      --------
 |      numpy.argpartition : equivalent function
 |  
 |  argsort(...)
 |      a.argsort(axis=-1, kind='quicksort', order=None)
 |      
 |      Returns the indices that would sort this array.
 |      
 |      Refer to `numpy.argsort` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argsort : equivalent function
 |  
 |  astype(...)
 |      a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)
 |      
 |      Copy of the array, cast to a specified type.
 |      
 |      Parameters
 |      ----------
 |      dtype : str or dtype
 |          Typecode or data-type to which the array is cast.
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          Controls the memory layout order of the result.
 |          'C' means C order, 'F' means Fortran order, 'A'
 |          means 'F' order if all the arrays are Fortran contiguous,
 |          'C' order otherwise, and 'K' means as close to the
 |          order the array elements appear in memory as possible.
 |          Default is 'K'.
 |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
 |          Controls what kind of data casting may occur. Defaults to 'unsafe'
 |          for backwards compatibility.
 |      
 |            * 'no' means the data types should not be cast at all.
 |            * 'equiv' means only byte-order changes are allowed.
 |            * 'safe' means only casts which can preserve values are allowed.
 |            * 'same_kind' means only safe casts or casts within a kind,
 |              like float64 to float32, are allowed.
 |            * 'unsafe' means any data conversions may be done.
 |      subok : bool, optional
 |          If True, then sub-classes will be passed-through (default), otherwise
 |          the returned array will be forced to be a base-class array.
 |      copy : bool, optional
 |          By default, astype always returns a newly allocated array. If this
 |          is set to false, and the `dtype`, `order`, and `subok`
 |          requirements are satisfied, the input array is returned instead
 |          of a copy.
 |      
 |      Returns
 |      -------
 |      arr_t : ndarray
 |          Unless `copy` is False and the other conditions for returning the input
 |          array are satisfied (see description for `copy` input parameter), `arr_t`
 |          is a new array of the same shape as the input array, with dtype, order
 |          given by `dtype`, `order`.
 |      
 |      Notes
 |      -----
 |      Starting in NumPy 1.9, astype method now returns an error if the string
 |      dtype to cast to is not long enough in 'safe' casting mode to hold the max
 |      value of integer/float array that is being casted. Previously the casting
 |      was allowed even if the result was truncated.
 |      
 |      Raises
 |      ------
 |      ComplexWarning
 |          When casting from complex to float or int. To avoid this,
 |          one should use ``a.real.astype(t)``.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 2.5])
 |      >>> x
 |      array([ 1. ,  2. ,  2.5])
 |      
 |      >>> x.astype(int)
 |      array([1, 2, 2])
 |  
 |  byteswap(...)
 |      a.byteswap(inplace=False)
 |      
 |      Swap the bytes of the array elements
 |      
 |      Toggle between low-endian and big-endian data representation by
 |      returning a byteswapped array, optionally swapped in-place.
 |      
 |      Parameters
 |      ----------
 |      inplace : bool, optional
 |          If ``True``, swap bytes in-place, default is ``False``.
 |      
 |      Returns
 |      -------
 |      out : ndarray
 |          The byteswapped array. If `inplace` is ``True``, this is
 |          a view to self.
 |      
 |      Examples
 |      --------
 |      >>> A = np.array([1, 256, 8755], dtype=np.int16)
 |      >>> map(hex, A)
 |      ['0x1', '0x100', '0x2233']
 |      >>> A.byteswap(inplace=True)
 |      array([  256,     1, 13090], dtype=int16)
 |      >>> map(hex, A)
 |      ['0x100', '0x1', '0x3322']
 |      
 |      Arrays of strings are not swapped
 |      
 |      >>> A = np.array(['ceg', 'fac'])
 |      >>> A.byteswap()
 |      array(['ceg', 'fac'],
 |            dtype='|S3')
 |  
 |  choose(...)
 |      a.choose(choices, out=None, mode='raise')
 |      
 |      Use an index array to construct a new array from a set of choices.
 |      
 |      Refer to `numpy.choose` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.choose : equivalent function
 |  
 |  clip(...)
 |      a.clip(min=None, max=None, out=None)
 |      
 |      Return an array whose values are limited to ``[min, max]``.
 |      One of max or min must be given.
 |      
 |      Refer to `numpy.clip` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.clip : equivalent function
 |  
 |  compress(...)
 |      a.compress(condition, axis=None, out=None)
 |      
 |      Return selected slices of this array along given axis.
 |      
 |      Refer to `numpy.compress` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.compress : equivalent function
 |  
 |  conj(...)
 |      a.conj()
 |      
 |      Complex-conjugate all elements.
 |      
 |      Refer to `numpy.conjugate` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.conjugate : equivalent function
 |  
 |  conjugate(...)
 |      a.conjugate()
 |      
 |      Return the complex conjugate, element-wise.
 |      
 |      Refer to `numpy.conjugate` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.conjugate : equivalent function
 |  
 |  copy(...)
 |      a.copy(order='C')
 |      
 |      Return a copy of the array.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          Controls the memory layout of the copy. 'C' means C-order,
 |          'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
 |          'C' otherwise. 'K' means match the layout of `a` as closely
 |          as possible. (Note that this function and :func:`numpy.copy` are very
 |          similar, but have different default values for their order=
 |          arguments.)
 |      
 |      See also
 |      --------
 |      numpy.copy
 |      numpy.copyto
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[1,2,3],[4,5,6]], order='F')
 |      
 |      >>> y = x.copy()
 |      
 |      >>> x.fill(0)
 |      
 |      >>> x
 |      array([[0, 0, 0],
 |             [0, 0, 0]])
 |      
 |      >>> y
 |      array([[1, 2, 3],
 |             [4, 5, 6]])
 |      
 |      >>> y.flags['C_CONTIGUOUS']
 |      True
 |  
 |  cumprod(...)
 |      a.cumprod(axis=None, dtype=None, out=None)
 |      
 |      Return the cumulative product of the elements along the given axis.
 |      
 |      Refer to `numpy.cumprod` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.cumprod : equivalent function
 |  
 |  cumsum(...)
 |      a.cumsum(axis=None, dtype=None, out=None)
 |      
 |      Return the cumulative sum of the elements along the given axis.
 |      
 |      Refer to `numpy.cumsum` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.cumsum : equivalent function
 |  
 |  diagonal(...)
 |      a.diagonal(offset=0, axis1=0, axis2=1)
 |      
 |      Return specified diagonals. In NumPy 1.9 the returned array is a
 |      read-only view instead of a copy as in previous NumPy versions.  In
 |      a future version the read-only restriction will be removed.
 |      
 |      Refer to :func:`numpy.diagonal` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.diagonal : equivalent function
 |  
 |  dot(...)
 |      a.dot(b, out=None)
 |      
 |      Dot product of two arrays.
 |      
 |      Refer to `numpy.dot` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.dot : equivalent function
 |      
 |      Examples
 |      --------
 |      >>> a = np.eye(2)
 |      >>> b = np.ones((2, 2)) * 2
 |      >>> a.dot(b)
 |      array([[ 2.,  2.],
 |             [ 2.,  2.]])
 |      
 |      This array method can be conveniently chained:
 |      
 |      >>> a.dot(b).dot(b)
 |      array([[ 8.,  8.],
 |             [ 8.,  8.]])
 |  
 |  dump(...)
 |      a.dump(file)
 |      
 |      Dump a pickle of the array to the specified file.
 |      The array can be read back with pickle.load or numpy.load.
 |      
 |      Parameters
 |      ----------
 |      file : str
 |          A string naming the dump file.
 |  
 |  dumps(...)
 |      a.dumps()
 |      
 |      Returns the pickle of the array as a string.
 |      pickle.loads or numpy.loads will convert the string back to an array.
 |      
 |      Parameters
 |      ----------
 |      None
 |  
 |  fill(...)
 |      a.fill(value)
 |      
 |      Fill the array with a scalar value.
 |      
 |      Parameters
 |      ----------
 |      value : scalar
 |          All elements of `a` will be assigned this value.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([1, 2])
 |      >>> a.fill(0)
 |      >>> a
 |      array([0, 0])
 |      >>> a = np.empty(2)
 |      >>> a.fill(1)
 |      >>> a
 |      array([ 1.,  1.])
 |  
 |  flatten(...)
 |      a.flatten(order='C')
 |      
 |      Return a copy of the array collapsed into one dimension.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          'C' means to flatten in row-major (C-style) order.
 |          'F' means to flatten in column-major (Fortran-
 |          style) order. 'A' means to flatten in column-major
 |          order if `a` is Fortran *contiguous* in memory,
 |          row-major order otherwise. 'K' means to flatten
 |          `a` in the order the elements occur in memory.
 |          The default is 'C'.
 |      
 |      Returns
 |      -------
 |      y : ndarray
 |          A copy of the input array, flattened to one dimension.
 |      
 |      See Also
 |      --------
 |      ravel : Return a flattened array.
 |      flat : A 1-D flat iterator over the array.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1,2], [3,4]])
 |      >>> a.flatten()
 |      array([1, 2, 3, 4])
 |      >>> a.flatten('F')
 |      array([1, 3, 2, 4])
 |  
 |  getfield(...)
 |      a.getfield(dtype, offset=0)
 |      
 |      Returns a field of the given array as a certain type.
 |      
 |      A field is a view of the array data with a given data-type. The values in
 |      the view are determined by the given type and the offset into the current
 |      array in bytes. The offset needs to be such that the view dtype fits in the
 |      array dtype; for example an array of dtype complex128 has 16-byte elements.
 |      If taking a view with a 32-bit integer (4 bytes), the offset needs to be
 |      between 0 and 12 bytes.
 |      
 |      Parameters
 |      ----------
 |      dtype : str or dtype
 |          The data type of the view. The dtype size of the view can not be larger
 |          than that of the array itself.
 |      offset : int
 |          Number of bytes to skip before beginning the element view.
 |      
 |      Examples
 |      --------
 |      >>> x = np.diag([1.+1.j]*2)
 |      >>> x[1, 1] = 2 + 4.j
 |      >>> x
 |      array([[ 1.+1.j,  0.+0.j],
 |             [ 0.+0.j,  2.+4.j]])
 |      >>> x.getfield(np.float64)
 |      array([[ 1.,  0.],
 |             [ 0.,  2.]])
 |      
 |      By choosing an offset of 8 bytes we can select the complex part of the
 |      array for our view:
 |      
 |      >>> x.getfield(np.float64, offset=8)
 |      array([[ 1.,  0.],
 |         [ 0.,  4.]])
 |  
 |  item(...)
 |      a.item(*args)
 |      
 |      Copy an element of an array to a standard Python scalar and return it.
 |      
 |      Parameters
 |      ----------
 |      \*args : Arguments (variable number and type)
 |      
 |          * none: in this case, the method only works for arrays
 |            with one element (`a.size == 1`), which element is
 |            copied into a standard Python scalar object and returned.
 |      
 |          * int_type: this argument is interpreted as a flat index into
 |            the array, specifying which element to copy and return.
 |      
 |          * tuple of int_types: functions as does a single int_type argument,
 |            except that the argument is interpreted as an nd-index into the
 |            array.
 |      
 |      Returns
 |      -------
 |      z : Standard Python scalar object
 |          A copy of the specified element of the array as a suitable
 |          Python scalar
 |      
 |      Notes
 |      -----
 |      When the data type of `a` is longdouble or clongdouble, item() returns
 |      a scalar array object because there is no available Python scalar that
 |      would not lose information. Void arrays return a buffer object for item(),
 |      unless fields are defined, in which case a tuple is returned.
 |      
 |      `item` is very similar to a[args], except, instead of an array scalar,
 |      a standard Python scalar is returned. This can be useful for speeding up
 |      access to elements of the array and doing arithmetic on elements of the
 |      array using Python's optimized math.
 |      
 |      Examples
 |      --------
 |      >>> x = np.random.randint(9, size=(3, 3))
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 8, 3],
 |             [8, 5, 3]])
 |      >>> x.item(3)
 |      2
 |      >>> x.item(7)
 |      5
 |      >>> x.item((0, 1))
 |      1
 |      >>> x.item((2, 2))
 |      3
 |  
 |  itemset(...)
 |      a.itemset(*args)
 |      
 |      Insert scalar into an array (scalar is cast to array's dtype, if possible)
 |      
 |      There must be at least 1 argument, and define the last argument
 |      as *item*.  Then, ``a.itemset(*args)`` is equivalent to but faster
 |      than ``a[args] = item``.  The item should be a scalar value and `args`
 |      must select a single item in the array `a`.
 |      
 |      Parameters
 |      ----------
 |      \*args : Arguments
 |          If one argument: a scalar, only used in case `a` is of size 1.
 |          If two arguments: the last argument is the value to be set
 |          and must be a scalar, the first argument specifies a single array
 |          element location. It is either an int or a tuple.
 |      
 |      Notes
 |      -----
 |      Compared to indexing syntax, `itemset` provides some speed increase
 |      for placing a scalar into a particular location in an `ndarray`,
 |      if you must do this.  However, generally this is discouraged:
 |      among other problems, it complicates the appearance of the code.
 |      Also, when using `itemset` (and `item`) inside a loop, be sure
 |      to assign the methods to a local variable to avoid the attribute
 |      look-up at each loop iteration.
 |      
 |      Examples
 |      --------
 |      >>> x = np.random.randint(9, size=(3, 3))
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 8, 3],
 |             [8, 5, 3]])
 |      >>> x.itemset(4, 0)
 |      >>> x.itemset((2, 2), 9)
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 0, 3],
 |             [8, 5, 9]])
 |  
 |  max(...)
 |      a.max(axis=None, out=None, keepdims=False)
 |      
 |      Return the maximum along a given axis.
 |      
 |      Refer to `numpy.amax` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.amax : equivalent function
 |  
 |  mean(...)
 |      a.mean(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Returns the average of the array elements along given axis.
 |      
 |      Refer to `numpy.mean` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.mean : equivalent function
 |  
 |  min(...)
 |      a.min(axis=None, out=None, keepdims=False)
 |      
 |      Return the minimum along a given axis.
 |      
 |      Refer to `numpy.amin` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.amin : equivalent function
 |  
 |  newbyteorder(...)
 |      arr.newbyteorder(new_order='S')
 |      
 |      Return the array with the same data viewed with a different byte order.
 |      
 |      Equivalent to::
 |      
 |          arr.view(arr.dtype.newbytorder(new_order))
 |      
 |      Changes are also made in all fields and sub-arrays of the array data
 |      type.
 |      
 |      
 |      
 |      Parameters
 |      ----------
 |      new_order : string, optional
 |          Byte order to force; a value from the byte order specifications
 |          below. `new_order` codes can be any of:
 |      
 |          * 'S' - swap dtype from current to opposite endian
 |          * {'<', 'L'} - little endian
 |          * {'>', 'B'} - big endian
 |          * {'=', 'N'} - native order
 |          * {'|', 'I'} - ignore (no change to byte order)
 |      
 |          The default value ('S') results in swapping the current
 |          byte order. The code does a case-insensitive check on the first
 |          letter of `new_order` for the alternatives above.  For example,
 |          any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 |      
 |      
 |      Returns
 |      -------
 |      new_arr : array
 |          New array object with the dtype reflecting given change to the
 |          byte order.
 |  
 |  nonzero(...)
 |      a.nonzero()
 |      
 |      Return the indices of the elements that are non-zero.
 |      
 |      Refer to `numpy.nonzero` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.nonzero : equivalent function
 |  
 |  partition(...)
 |      a.partition(kth, axis=-1, kind='introselect', order=None)
 |      
 |      Rearranges the elements in the array in such a way that value of the
 |      element in kth position is in the position it would be in a sorted array.
 |      All elements smaller than the kth element are moved before this element and
 |      all equal or greater are moved behind it. The ordering of the elements in
 |      the two partitions is undefined.
 |      
 |      .. versionadded:: 1.8.0
 |      
 |      Parameters
 |      ----------
 |      kth : int or sequence of ints
 |          Element index to partition by. The kth element value will be in its
 |          final sorted position and all smaller elements will be moved before it
 |          and all equal or greater elements behind it.
 |          The order all elements in the partitions is undefined.
 |          If provided with a sequence of kth it will partition all elements
 |          indexed by kth of them into their sorted position at once.
 |      axis : int, optional
 |          Axis along which to sort. Default is -1, which means sort along the
 |          last axis.
 |      kind : {'introselect'}, optional
 |          Selection algorithm. Default is 'introselect'.
 |      order : str or list of str, optional
 |          When `a` is an array with fields defined, this argument specifies
 |          which fields to compare first, second, etc.  A single field can
 |          be specified as a string, and not all fields need be specified,
 |          but unspecified fields will still be used, in the order in which
 |          they come up in the dtype, to break ties.
 |      
 |      See Also
 |      --------
 |      numpy.partition : Return a parititioned copy of an array.
 |      argpartition : Indirect partition.
 |      sort : Full sort.
 |      
 |      Notes
 |      -----
 |      See ``np.partition`` for notes on the different algorithms.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([3, 4, 2, 1])
 |      >>> a.partition(3)
 |      >>> a
 |      array([2, 1, 3, 4])
 |      
 |      >>> a.partition((1, 3))
 |      array([1, 2, 3, 4])
 |  
 |  prod(...)
 |      a.prod(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Return the product of the array elements over the given axis
 |      
 |      Refer to `numpy.prod` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.prod : equivalent function
 |  
 |  ptp(...)
 |      a.ptp(axis=None, out=None)
 |      
 |      Peak to peak (maximum - minimum) value along a given axis.
 |      
 |      Refer to `numpy.ptp` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.ptp : equivalent function
 |  
 |  put(...)
 |      a.put(indices, values, mode='raise')
 |      
 |      Set ``a.flat[n] = values[n]`` for all `n` in indices.
 |      
 |      Refer to `numpy.put` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.put : equivalent function
 |  
 |  ravel(...)
 |      a.ravel([order])
 |      
 |      Return a flattened array.
 |      
 |      Refer to `numpy.ravel` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.ravel : equivalent function
 |      
 |      ndarray.flat : a flat iterator on the array.
 |  
 |  repeat(...)
 |      a.repeat(repeats, axis=None)
 |      
 |      Repeat elements of an array.
 |      
 |      Refer to `numpy.repeat` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.repeat : equivalent function
 |  
 |  reshape(...)
 |      a.reshape(shape, order='C')
 |      
 |      Returns an array containing the same data with a new shape.
 |      
 |      Refer to `numpy.reshape` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.reshape : equivalent function
 |      
 |      Notes
 |      -----
 |      Unlike the free function `numpy.reshape`, this method on `ndarray` allows
 |      the elements of the shape parameter to be passed in as separate arguments.
 |      For example, ``a.reshape(10, 11)`` is equivalent to
 |      ``a.reshape((10, 11))``.
 |  
 |  resize(...)
 |      a.resize(new_shape, refcheck=True)
 |      
 |      Change shape and size of array in-place.
 |      
 |      Parameters
 |      ----------
 |      new_shape : tuple of ints, or `n` ints
 |          Shape of resized array.
 |      refcheck : bool, optional
 |          If False, reference count will not be checked. Default is True.
 |      
 |      Returns
 |      -------
 |      None
 |      
 |      Raises
 |      ------
 |      ValueError
 |          If `a` does not own its own data or references or views to it exist,
 |          and the data memory must be changed.
 |          PyPy only: will always raise if the data memory must be changed, since
 |          there is no reliable way to determine if references or views to it
 |          exist.
 |      
 |      SystemError
 |          If the `order` keyword argument is specified. This behaviour is a
 |          bug in NumPy.
 |      
 |      See Also
 |      --------
 |      resize : Return a new array with the specified shape.
 |      
 |      Notes
 |      -----
 |      This reallocates space for the data area if necessary.
 |      
 |      Only contiguous arrays (data elements consecutive in memory) can be
 |      resized.
 |      
 |      The purpose of the reference count check is to make sure you
 |      do not use this array as a buffer for another Python object and then
 |      reallocate the memory. However, reference counts can increase in
 |      other ways so if you are sure that you have not shared the memory
 |      for this array with another Python object, then you may safely set
 |      `refcheck` to False.
 |      
 |      Examples
 |      --------
 |      Shrinking an array: array is flattened (in the order that the data are
 |      stored in memory), resized, and reshaped:
 |      
 |      >>> a = np.array([[0, 1], [2, 3]], order='C')
 |      >>> a.resize((2, 1))
 |      >>> a
 |      array([[0],
 |             [1]])
 |      
 |      >>> a = np.array([[0, 1], [2, 3]], order='F')
 |      >>> a.resize((2, 1))
 |      >>> a
 |      array([[0],
 |             [2]])
 |      
 |      Enlarging an array: as above, but missing entries are filled with zeros:
 |      
 |      >>> b = np.array([[0, 1], [2, 3]])
 |      >>> b.resize(2, 3) # new_shape parameter doesn't have to be a tuple
 |      >>> b
 |      array([[0, 1, 2],
 |             [3, 0, 0]])
 |      
 |      Referencing an array prevents resizing...
 |      
 |      >>> c = a
 |      >>> a.resize((1, 1))
 |      Traceback (most recent call last):
 |      ...
 |      ValueError: cannot resize an array that has been referenced ...
 |      
 |      Unless `refcheck` is False:
 |      
 |      >>> a.resize((1, 1), refcheck=False)
 |      >>> a
 |      array([[0]])
 |      >>> c
 |      array([[0]])
 |  
 |  round(...)
 |      a.round(decimals=0, out=None)
 |      
 |      Return `a` with each element rounded to the given number of decimals.
 |      
 |      Refer to `numpy.around` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.around : equivalent function
 |  
 |  searchsorted(...)
 |      a.searchsorted(v, side='left', sorter=None)
 |      
 |      Find indices where elements of v should be inserted in a to maintain order.
 |      
 |      For full documentation, see `numpy.searchsorted`
 |      
 |      See Also
 |      --------
 |      numpy.searchsorted : equivalent function
 |  
 |  setfield(...)
 |      a.setfield(val, dtype, offset=0)
 |      
 |      Put a value into a specified place in a field defined by a data-type.
 |      
 |      Place `val` into `a`'s field defined by `dtype` and beginning `offset`
 |      bytes into the field.
 |      
 |      Parameters
 |      ----------
 |      val : object
 |          Value to be placed in field.
 |      dtype : dtype object
 |          Data-type of the field in which to place `val`.
 |      offset : int, optional
 |          The number of bytes into the field at which to place `val`.
 |      
 |      Returns
 |      -------
 |      None
 |      
 |      See Also
 |      --------
 |      getfield
 |      
 |      Examples
 |      --------
 |      >>> x = np.eye(3)
 |      >>> x.getfield(np.float64)
 |      array([[ 1.,  0.,  0.],
 |             [ 0.,  1.,  0.],
 |             [ 0.,  0.,  1.]])
 |      >>> x.setfield(3, np.int32)
 |      >>> x.getfield(np.int32)
 |      array([[3, 3, 3],
 |             [3, 3, 3],
 |             [3, 3, 3]])
 |      >>> x
 |      array([[  1.00000000e+000,   1.48219694e-323,   1.48219694e-323],
 |             [  1.48219694e-323,   1.00000000e+000,   1.48219694e-323],
 |             [  1.48219694e-323,   1.48219694e-323,   1.00000000e+000]])
 |      >>> x.setfield(np.eye(3), np.int32)
 |      >>> x
 |      array([[ 1.,  0.,  0.],
 |             [ 0.,  1.,  0.],
 |             [ 0.,  0.,  1.]])
 |  
 |  setflags(...)
 |      a.setflags(write=None, align=None, uic=None)
 |      
 |      Set array flags WRITEABLE, ALIGNED, (WRITEBACKIFCOPY and UPDATEIFCOPY),
 |      respectively.
 |      
 |      These Boolean-valued flags affect how numpy interprets the memory
 |      area used by `a` (see Notes below). The ALIGNED flag can only
 |      be set to True if the data is actually aligned according to the type.
 |      The WRITEBACKIFCOPY and (deprecated) UPDATEIFCOPY flags can never be set
 |      to True. The flag WRITEABLE can only be set to True if the array owns its
 |      own memory, or the ultimate owner of the memory exposes a writeable buffer
 |      interface, or is a string. (The exception for string is made so that
 |      unpickling can be done without copying memory.)
 |      
 |      Parameters
 |      ----------
 |      write : bool, optional
 |          Describes whether or not `a` can be written to.
 |      align : bool, optional
 |          Describes whether or not `a` is aligned properly for its type.
 |      uic : bool, optional
 |          Describes whether or not `a` is a copy of another ""base"" array.
 |      
 |      Notes
 |      -----
 |      Array flags provide information about how the memory area used
 |      for the array is to be interpreted. There are 7 Boolean flags
 |      in use, only four of which can be changed by the user:
 |      WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED.
 |      
 |      WRITEABLE (W) the data area can be written to;
 |      
 |      ALIGNED (A) the data and strides are aligned appropriately for the hardware
 |      (as determined by the compiler);
 |      
 |      UPDATEIFCOPY (U) (deprecated), replaced by WRITEBACKIFCOPY;
 |      
 |      WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced
 |      by .base). When the C-API function PyArray_ResolveWritebackIfCopy is
 |      called, the base array will be updated with the contents of this array.
 |      
 |      All flags can be accessed using the single (upper case) letter as well
 |      as the full name.
 |      
 |      Examples
 |      --------
 |      >>> y
 |      array([[3, 1, 7],
 |             [2, 0, 0],
 |             [8, 5, 9]])
 |      >>> y.flags
 |        C_CONTIGUOUS : True
 |        F_CONTIGUOUS : False
 |        OWNDATA : True
 |        WRITEABLE : True
 |        ALIGNED : True
 |        WRITEBACKIFCOPY : False
 |        UPDATEIFCOPY : False
 |      >>> y.setflags(write=0, align=0)
 |      >>> y.flags
 |        C_CONTIGUOUS : True
 |        F_CONTIGUOUS : False
 |        OWNDATA : True
 |        WRITEABLE : False
 |        ALIGNED : False
 |        WRITEBACKIFCOPY : False
 |        UPDATEIFCOPY : False
 |      >>> y.setflags(uic=1)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: cannot set WRITEBACKIFCOPY flag to True
 |  
 |  sort(...)
 |      a.sort(axis=-1, kind='quicksort', order=None)
 |      
 |      Sort an array, in-place.
 |      
 |      Parameters
 |      ----------
 |      axis : int, optional
 |          Axis along which to sort. Default is -1, which means sort along the
 |          last axis.
 |      kind : {'quicksort', 'mergesort', 'heapsort'}, optional
 |          Sorting algorithm. Default is 'quicksort'.
 |      order : str or list of str, optional
 |          When `a` is an array with fields defined, this argument specifies
 |          which fields to compare first, second, etc.  A single field can
 |          be specified as a string, and not all fields need be specified,
 |          but unspecified fields will still be used, in the order in which
 |          they come up in the dtype, to break ties.
 |      
 |      See Also
 |      --------
 |      numpy.sort : Return a sorted copy of an array.
 |      argsort : Indirect sort.
 |      lexsort : Indirect stable sort on multiple keys.
 |      searchsorted : Find elements in sorted array.
 |      partition: Partial sort.
 |      
 |      Notes
 |      -----
 |      See ``sort`` for notes on the different sorting algorithms.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1,4], [3,1]])
 |      >>> a.sort(axis=1)
 |      >>> a
 |      array([[1, 4],
 |             [1, 3]])
 |      >>> a.sort(axis=0)
 |      >>> a
 |      array([[1, 3],
 |             [1, 4]])
 |      
 |      Use the `order` keyword to specify a field to use when sorting a
 |      structured array:
 |      
 |      >>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])
 |      >>> a.sort(order='y')
 |      >>> a
 |      array([('c', 1), ('a', 2)],
 |            dtype=[('x', '|S1'), ('y', '<i4')])
 |  
 |  squeeze(...)
 |      a.squeeze(axis=None)
 |      
 |      Remove single-dimensional entries from the shape of `a`.
 |      
 |      Refer to `numpy.squeeze` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.squeeze : equivalent function
 |  
 |  std(...)
 |      a.std(axis=None, dtype=None, out=None, ddof=0, keepdims=False)
 |      
 |      Returns the standard deviation of the array elements along given axis.
 |      
 |      Refer to `numpy.std` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.std : equivalent function
 |  
 |  sum(...)
 |      a.sum(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Return the sum of the array elements over the given axis.
 |      
 |      Refer to `numpy.sum` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.sum : equivalent function
 |  
 |  swapaxes(...)
 |      a.swapaxes(axis1, axis2)
 |      
 |      Return a view of the array with `axis1` and `axis2` interchanged.
 |      
 |      Refer to `numpy.swapaxes` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.swapaxes : equivalent function
 |  
 |  take(...)
 |      a.take(indices, axis=None, out=None, mode='raise')
 |      
 |      Return an array formed from the elements of `a` at the given indices.
 |      
 |      Refer to `numpy.take` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.take : equivalent function
 |  
 |  tobytes(...)
 |      a.tobytes(order='C')
 |      
 |      Construct Python bytes containing the raw data bytes in the array.
 |      
 |      Constructs Python bytes showing a copy of the raw contents of
 |      data memory. The bytes object can be produced in either 'C' or 'Fortran',
 |      or 'Any' order (the default is 'C'-order). 'Any' order means C-order
 |      unless the F_CONTIGUOUS flag in the array is set, in which case it
 |      means 'Fortran' order.
 |      
 |      .. versionadded:: 1.9.0
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', None}, optional
 |          Order of the data for multidimensional arrays:
 |          C, Fortran, or the same as for the original array.
 |      
 |      Returns
 |      -------
 |      s : bytes
 |          Python bytes exhibiting a copy of `a`'s raw data.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[0, 1], [2, 3]])
 |      >>> x.tobytes()
 |      b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
 |      >>> x.tobytes('C') == x.tobytes()
 |      True
 |      >>> x.tobytes('F')
 |      b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
 |  
 |  tofile(...)
 |      a.tofile(fid, sep="""", format=""%s"")
 |      
 |      Write array to a file as text or binary (default).
 |      
 |      Data is always written in 'C' order, independent of the order of `a`.
 |      The data produced by this method can be recovered using the function
 |      fromfile().
 |      
 |      Parameters
 |      ----------
 |      fid : file or str
 |          An open file object, or a string containing a filename.
 |      sep : str
 |          Separator between array items for text output.
 |          If """" (empty), a binary file is written, equivalent to
 |          ``file.write(a.tobytes())``.
 |      format : str
 |          Format string for text file output.
 |          Each entry in the array is formatted to text by first converting
 |          it to the closest Python type, and then using ""format"" % item.
 |      
 |      Notes
 |      -----
 |      This is a convenience function for quick storage of array data.
 |      Information on endianness and precision is lost, so this method is not a
 |      good choice for files intended to archive data or transport data between
 |      machines with different endianness. Some of these problems can be overcome
 |      by outputting the data as text files, at the expense of speed and file
 |      size.
 |  
 |  tolist(...)
 |      a.tolist()
 |      
 |      Return the array as a (possibly nested) list.
 |      
 |      Return a copy of the array data as a (nested) Python list.
 |      Data items are converted to the nearest compatible Python type.
 |      
 |      Parameters
 |      ----------
 |      none
 |      
 |      Returns
 |      -------
 |      y : list
 |          The possibly nested list of array elements.
 |      
 |      Notes
 |      -----
 |      The array may be recreated, ``a = np.array(a.tolist())``.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([1, 2])
 |      >>> a.tolist()
 |      [1, 2]
 |      >>> a = np.array([[1, 2], [3, 4]])
 |      >>> list(a)
 |      [array([1, 2]), array([3, 4])]
 |      >>> a.tolist()
 |      [[1, 2], [3, 4]]
 |  
 |  tostring(...)
 |      a.tostring(order='C')
 |      
 |      Construct Python bytes containing the raw data bytes in the array.
 |      
 |      Constructs Python bytes showing a copy of the raw contents of
 |      data memory. The bytes object can be produced in either 'C' or 'Fortran',
 |      or 'Any' order (the default is 'C'-order). 'Any' order means C-order
 |      unless the F_CONTIGUOUS flag in the array is set, in which case it
 |      means 'Fortran' order.
 |      
 |      This function is a compatibility alias for tobytes. Despite its name it returns bytes not strings.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', None}, optional
 |          Order of the data for multidimensional arrays:
 |          C, Fortran, or the same as for the original array.
 |      
 |      Returns
 |      -------
 |      s : bytes
 |          Python bytes exhibiting a copy of `a`'s raw data.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[0, 1], [2, 3]])
 |      >>> x.tobytes()
 |      b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
 |      >>> x.tobytes('C') == x.tobytes()
 |      True
 |      >>> x.tobytes('F')
 |      b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
 |  
 |  trace(...)
 |      a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)
 |      
 |      Return the sum along diagonals of the array.
 |      
 |      Refer to `numpy.trace` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.trace : equivalent function
 |  
 |  transpose(...)
 |      a.transpose(*axes)
 |      
 |      Returns a view of the array with axes transposed.
 |      
 |      For a 1-D array, this has no effect. (To change between column and
 |      row vectors, first cast the 1-D array into a matrix object.)
 |      For a 2-D array, this is the usual matrix transpose.
 |      For an n-D array, if axes are given, their order indicates how the
 |      axes are permuted (see Examples). If axes are not provided and
 |      ``a.shape = (i[0], i[1], ... i[n-2], i[n-1])``, then
 |      ``a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0])``.
 |      
 |      Parameters
 |      ----------
 |      axes : None, tuple of ints, or `n` ints
 |      
 |       * None or no argument: reverses the order of the axes.
 |      
 |       * tuple of ints: `i` in the `j`-th place in the tuple means `a`'s
 |         `i`-th axis becomes `a.transpose()`'s `j`-th axis.
 |      
 |       * `n` ints: same as an n-tuple of the same ints (this form is
 |         intended simply as a ""convenience"" alternative to the tuple form)
 |      
 |      Returns
 |      -------
 |      out : ndarray
 |          View of `a`, with axes suitably permuted.
 |      
 |      See Also
 |      --------
 |      ndarray.T : Array property returning the array transposed.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1, 2], [3, 4]])
 |      >>> a
 |      array([[1, 2],
 |             [3, 4]])
 |      >>> a.transpose()
 |      array([[1, 3],
 |             [2, 4]])
 |      >>> a.transpose((1, 0))
 |      array([[1, 3],
 |             [2, 4]])
 |      >>> a.transpose(1, 0)
 |      array([[1, 3],
 |             [2, 4]])
 |  
 |  var(...)
 |      a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False)
 |      
 |      Returns the variance of the array elements, along given axis.
 |      
 |      Refer to `numpy.var` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.var : equivalent function
 |  
 |  view(...)
 |      a.view(dtype=None, type=None)
 |      
 |      New view of array with the same data.
 |      
 |      Parameters
 |      ----------
 |      dtype : data-type or ndarray sub-class, optional
 |          Data-type descriptor of the returned view, e.g., float32 or int16. The
 |          default, None, results in the view having the same data-type as `a`.
 |          This argument can also be specified as an ndarray sub-class, which
 |          then specifies the type of the returned object (this is equivalent to
 |          setting the ``type`` parameter).
 |      type : Python type, optional
 |          Type of the returned view, e.g., ndarray or matrix.  Again, the
 |          default None results in type preservation.
 |      
 |      Notes
 |      -----
 |      ``a.view()`` is used two different ways:
 |      
 |      ``a.view(some_dtype)`` or ``a.view(dtype=some_dtype)`` constructs a view
 |      of the array's memory with a different data-type.  This can cause a
 |      reinterpretation of the bytes of memory.
 |      
 |      ``a.view(ndarray_subclass)`` or ``a.view(type=ndarray_subclass)`` just
 |      returns an instance of `ndarray_subclass` that looks at the same array
 |      (same shape, dtype, etc.)  This does not cause a reinterpretation of the
 |      memory.
 |      
 |      For ``a.view(some_dtype)``, if ``some_dtype`` has a different number of
 |      bytes per entry than the previous dtype (for example, converting a
 |      regular array to a structured array), then the behavior of the view
 |      cannot be predicted just from the superficial appearance of ``a`` (shown
 |      by ``print(a)``). It also depends on exactly how ``a`` is stored in
 |      memory. Therefore if ``a`` is C-ordered versus fortran-ordered, versus
 |      defined as a slice or transpose, etc., the view may give different
 |      results.
 |      
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])
 |      
 |      Viewing array data using a different type and dtype:
 |      
 |      >>> y = x.view(dtype=np.int16, type=np.matrix)
 |      >>> y
 |      matrix([[513]], dtype=int16)
 |      >>> print(type(y))
 |      <class 'numpy.matrixlib.defmatrix.matrix'>
 |      
 |      Creating a view on a structured array so it can be used in calculations
 |      
 |      >>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)])
 |      >>> xv = x.view(dtype=np.int8).reshape(-1,2)
 |      >>> xv
 |      array([[1, 2],
 |             [3, 4]], dtype=int8)
 |      >>> xv.mean(0)
 |      array([ 2.,  3.])
 |      
 |      Making changes to the view changes the underlying array
 |      
 |      >>> xv[0,1] = 20
 |      >>> print(x)
 |      [(1, 20) (3, 4)]
 |      
 |      Using a view to convert an array to a recarray:
 |      
 |      >>> z = x.view(np.recarray)
 |      >>> z.a
 |      array([1], dtype=int8)
 |      
 |      Views share data:
 |      
 |      >>> x[0] = (9, 10)
 |      >>> z[0]
 |      (9, 10)
 |      
 |      Views that change the dtype size (bytes per entry) should normally be
 |      avoided on arrays defined by slices, transposes, fortran-ordering, etc.:
 |      
 |      >>> x = np.array([[1,2,3],[4,5,6]], dtype=np.int16)
 |      >>> y = x[:, 0:2]
 |      >>> y
 |      array([[1, 2],
 |             [4, 5]], dtype=int16)
 |      >>> y.view(dtype=[('width', np.int16), ('length', np.int16)])
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: new type not compatible with array.
 |      >>> z = y.copy()
 |      >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
 |      array([[(1, 2)],
 |             [(4, 5)]], dtype=[('width', '<i2'), ('length', '<i2')])
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from numpy.ndarray:
 |  
 |  T
 |      Same as self.transpose(), except that self is returned if
 |      self.ndim < 2.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[1.,2.],[3.,4.]])
 |      >>> x
 |      array([[ 1.,  2.],
 |             [ 3.,  4.]])
 |      >>> x.T
 |      array([[ 1.,  3.],
 |             [ 2.,  4.]])
 |      >>> x = np.array([1.,2.,3.,4.])
 |      >>> x
 |      array([ 1.,  2.,  3.,  4.])
 |      >>> x.T
 |      array([ 1.,  2.,  3.,  4.])
 |  
 |  __array_interface__
 |      Array protocol: Python side.
 |  
 |  __array_priority__
 |      Array priority.
 |  
 |  __array_struct__
 |      Array protocol: C-struct side.
 |  
 |  base
 |      Base object if memory is from some other object.
 |      
 |      Examples
 |      --------
 |      The base of an array that owns its memory is None:
 |      
 |      >>> x = np.array([1,2,3,4])
 |      >>> x.base is None
 |      True
 |      
 |      Slicing creates a view, whose memory is shared with x:
 |      
 |      >>> y = x[2:]
 |      >>> y.base is x
 |      True
 |  
 |  ctypes
 |      An object to simplify the interaction of the array with the ctypes
 |      module.
 |      
 |      This attribute creates an object that makes it easier to use arrays
 |      when calling shared libraries with the ctypes module. The returned
 |      object has, among others, data, shape, and strides attributes (see
 |      Notes below) which themselves return ctypes objects that can be used
 |      as arguments to a shared library.
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      c : Python object
 |          Possessing attributes data, shape, strides, etc.
 |      
 |      See Also
 |      --------
 |      numpy.ctypeslib
 |      
 |      Notes
 |      -----
 |      Below are the public attributes of this object which were documented
 |      in ""Guide to NumPy"" (we have omitted undocumented public attributes,
 |      as well as documented private attributes):
 |      
 |      * data: A pointer to the memory area of the array as a Python integer.
 |        This memory area may contain data that is not aligned, or not in correct
 |        byte-order. The memory area may not even be writeable. The array
 |        flags and data-type of this array should be respected when passing this
 |        attribute to arbitrary C-code to avoid trouble that can include Python
 |        crashing. User Beware! The value of this attribute is exactly the same
 |        as self._array_interface_['data'][0].
 |      
 |      * shape (c_intp*self.ndim): A ctypes array of length self.ndim where
 |        the basetype is the C-integer corresponding to dtype('p') on this
 |        platform. This base-type could be c_int, c_long, or c_longlong
 |        depending on the platform. The c_intp type is defined accordingly in
 |        numpy.ctypeslib. The ctypes array contains the shape of the underlying
 |        array.
 |      
 |      * strides (c_intp*self.ndim): A ctypes array of length self.ndim where
 |        the basetype is the same as for the shape attribute. This ctypes array
 |        contains the strides information from the underlying array. This strides
 |        information is important for showing how many bytes must be jumped to
 |        get to the next element in the array.
 |      
 |      * data_as(obj): Return the data pointer cast to a particular c-types object.
 |        For example, calling self._as_parameter_ is equivalent to
 |        self.data_as(ctypes.c_void_p). Perhaps you want to use the data as a
 |        pointer to a ctypes array of floating-point data:
 |        self.data_as(ctypes.POINTER(ctypes.c_double)).
 |      
 |      * shape_as(obj): Return the shape tuple as an array of some other c-types
 |        type. For example: self.shape_as(ctypes.c_short).
 |      
 |      * strides_as(obj): Return the strides tuple as an array of some other
 |        c-types type. For example: self.strides_as(ctypes.c_longlong).
 |      
 |      Be careful using the ctypes attribute - especially on temporary
 |      arrays or arrays constructed on the fly. For example, calling
 |      ``(a+b).ctypes.data_as(ctypes.c_void_p)`` returns a pointer to memory
 |      that is invalid because the array created as (a+b) is deallocated
 |      before the next Python statement. You can avoid this problem using
 |      either ``c=a+b`` or ``ct=(a+b).ctypes``. In the latter case, ct will
 |      hold a reference to the array until ct is deleted or re-assigned.
 |      
 |      If the ctypes module is not available, then the ctypes attribute
 |      of array objects still returns something useful, but ctypes objects
 |      are not returned and errors may be raised instead. In particular,
 |      the object will still have the as parameter attribute which will
 |      return an integer equal to the data attribute.
 |      
 |      Examples
 |      --------
 |      >>> import ctypes
 |      >>> x
 |      array([[0, 1],
 |             [2, 3]])
 |      >>> x.ctypes.data
 |      30439712
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long))
 |      <ctypes.LP_c_long object at 0x01F01300>
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)).contents
 |      c_long(0)
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_longlong)).contents
 |      c_longlong(4294967296L)
 |      >>> x.ctypes.shape
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FFD580>
 |      >>> x.ctypes.shape_as(ctypes.c_long)
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
 |      >>> x.ctypes.strides
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
 |      >>> x.ctypes.strides_as(ctypes.c_longlong)
 |      <numpy.core._internal.c_longlong_Array_2 object at 0x01F01300>
 |  
 |  data
 |      Python buffer object pointing to the start of the array's data.
 |  
 |  dtype
 |      Data-type of the array's elements.
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      d : numpy dtype object
 |      
 |      See Also
 |      --------
 |      numpy.dtype
 |      
 |      Examples
 |      --------
 |      >>> x
 |      array([[0, 1],
 |             [2, 3]])
 |      >>> x.dtype
 |      dtype('int32')
 |      >>> type(x.dtype)
 |      <type 'numpy.dtype'>
 |  
 |  flags
 |      Information about the memory layout of the array.
 |      
 |      Attributes
 |      ----------
 |      C_CONTIGUOUS (C)
 |          The data is in a single, C-style contiguous segment.
 |      F_CONTIGUOUS (F)
 |          The data is in a single, Fortran-style contiguous segment.
 |      OWNDATA (O)
 |          The array owns the memory it uses or borrows it from another object.
 |      WRITEABLE (W)
 |          The data area can be written to.  Setting this to False locks
 |          the data, making it read-only.  A view (slice, etc.) inherits WRITEABLE
 |          from its base array at creation time, but a view of a writeable
 |          array may be subsequently locked while the base array remains writeable.
 |          (The opposite is not true, in that a view of a locked array may not
 |          be made writeable.  However, currently, locking a base object does not
 |          lock any views that already reference it, so under that circumstance it
 |          is possible to alter the contents of a locked array via a previously
 |          created writeable view onto it.)  Attempting to change a non-writeable
 |          array raises a RuntimeError exception.
 |      ALIGNED (A)
 |          The data and all elements are aligned appropriately for the hardware.
 |      WRITEBACKIFCOPY (X)
 |          This array is a copy of some other array. The C-API function
 |          PyArray_ResolveWritebackIfCopy must be called before deallocating
 |          to the base array will be updated with the contents of this array.
 |      UPDATEIFCOPY (U)
 |          (Deprecated, use WRITEBACKIFCOPY) This array is a copy of some other array.
 |          When this array is
 |          deallocated, the base array will be updated with the contents of
 |          this array.
 |      FNC
 |          F_CONTIGUOUS and not C_CONTIGUOUS.
 |      FORC
 |          F_CONTIGUOUS or C_CONTIGUOUS (one-segment test).
 |      BEHAVED (B)
 |          ALIGNED and WRITEABLE.
 |      CARRAY (CA)
 |          BEHAVED and C_CONTIGUOUS.
 |      FARRAY (FA)
 |          BEHAVED and F_CONTIGUOUS and not C_CONTIGUOUS.
 |      
 |      Notes
 |      -----
 |      The `flags` object can be accessed dictionary-like (as in ``a.flags['WRITEABLE']``),
 |      or by using lowercased attribute names (as in ``a.flags.writeable``). Short flag
 |      names are only supported in dictionary access.
 |      
 |      Only the WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED flags can be
 |      changed by the user, via direct assignment to the attribute or dictionary
 |      entry, or by calling `ndarray.setflags`.
 |      
 |      The array flags cannot be set arbitrarily:
 |      
 |      - UPDATEIFCOPY can only be set ``False``.
 |      - WRITEBACKIFCOPY can only be set ``False``.
 |      - ALIGNED can only be set ``True`` if the data is truly aligned.
 |      - WRITEABLE can only be set ``True`` if the array owns its own memory
 |        or the ultimate owner of the memory exposes a writeable buffer
 |        interface or is a string.
 |      
 |      Arrays can be both C-style and Fortran-style contiguous simultaneously.
 |      This is clear for 1-dimensional arrays, but can also be true for higher
 |      dimensional arrays.
 |      
 |      Even for contiguous arrays a stride for a given dimension
 |      ``arr.strides[dim]`` may be *arbitrary* if ``arr.shape[dim] == 1``
 |      or the array has no elements.
 |      It does *not* generally hold that ``self.strides[-1] == self.itemsize``
 |      for C-style contiguous arrays or ``self.strides[0] == self.itemsize`` for
 |      Fortran-style contiguous arrays is true.
 |  
 |  flat
 |      A 1-D iterator over the array.
 |      
 |      This is a `numpy.flatiter` instance, which acts similarly to, but is not
 |      a subclass of, Python's built-in iterator object.
 |      
 |      See Also
 |      --------
 |      flatten : Return a copy of the array collapsed into one dimension.
 |      
 |      flatiter
 |      
 |      Examples
 |      --------
 |      >>> x = np.arange(1, 7).reshape(2, 3)
 |      >>> x
 |      array([[1, 2, 3],
 |             [4, 5, 6]])
 |      >>> x.flat[3]
 |      4
 |      >>> x.T
 |      array([[1, 4],
 |             [2, 5],
 |             [3, 6]])
 |      >>> x.T.flat[3]
 |      5
 |      >>> type(x.flat)
 |      <type 'numpy.flatiter'>
 |      
 |      An assignment example:
 |      
 |      >>> x.flat = 3; x
 |      array([[3, 3, 3],
 |             [3, 3, 3]])
 |      >>> x.flat[[1,4]] = 1; x
 |      array([[3, 1, 3],
 |             [3, 1, 3]])
 |  
 |  imag
 |      The imaginary part of the array.
 |      
 |      Examples
 |      --------
 |      >>> x = np.sqrt([1+0j, 0+1j])
 |      >>> x.imag
 |      array([ 0.        ,  0.70710678])
 |      >>> x.imag.dtype
 |      dtype('float64')
 |  
 |  itemsize
 |      Length of one array element in bytes.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1,2,3], dtype=np.float64)
 |      >>> x.itemsize
 |      8
 |      >>> x = np.array([1,2,3], dtype=np.complex128)
 |      >>> x.itemsize
 |      16
 |  
 |  nbytes
 |      Total bytes consumed by the elements of the array.
 |      
 |      Notes
 |      -----
 |      Does not include memory consumed by non-element attributes of the
 |      array object.
 |      
 |      Examples
 |      --------
 |      >>> x = np.zeros((3,5,2), dtype=np.complex128)
 |      >>> x.nbytes
 |      480
 |      >>> np.prod(x.shape) * x.itemsize
 |      480
 |  
 |  ndim
 |      Number of array dimensions.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 3])
 |      >>> x.ndim
 |      1
 |      >>> y = np.zeros((2, 3, 4))
 |      >>> y.ndim
 |      3
 |  
 |  real
 |      The real part of the array.
 |      
 |      Examples
 |      --------
 |      >>> x = np.sqrt([1+0j, 0+1j])
 |      >>> x.real
 |      array([ 1.        ,  0.70710678])
 |      >>> x.real.dtype
 |      dtype('float64')
 |      
 |      See Also
 |      --------
 |      numpy.real : equivalent function
 |  
 |  shape
 |      Tuple of array dimensions.
 |      
 |      The shape property is usually used to get the current shape of an array,
 |      but may also be used to reshape the array in-place by assigning a tuple of
 |      array dimensions to it.  As with `numpy.reshape`, one of the new shape
 |      dimensions can be -1, in which case its value is inferred from the size of
 |      the array and the remaining dimensions. Reshaping an array in-place will
 |      fail if a copy is required.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 3, 4])
 |      >>> x.shape
 |      (4,)
 |      >>> y = np.zeros((2, 3, 4))
 |      >>> y.shape
 |      (2, 3, 4)
 |      >>> y.shape = (3, 8)
 |      >>> y
 |      array([[ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
 |             [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
 |             [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.]])
 |      >>> y.shape = (3, 6)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: total size of new array must be unchanged
 |      >>> np.zeros((4,2))[::2].shape = (-1,)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      AttributeError: incompatible shape for a non-contiguous array
 |      
 |      See Also
 |      --------
 |      numpy.reshape : similar function
 |      ndarray.reshape : similar method
 |  
 |  size
 |      Number of elements in the array.
 |      
 |      Equivalent to ``np.prod(a.shape)``, i.e., the product of the array's
 |      dimensions.
 |      
 |      Examples
 |      --------
 |      >>> x = np.zeros((3, 5, 2), dtype=np.complex128)
 |      >>> x.size
 |      30
 |      >>> np.prod(x.shape)
 |      30
 |  
 |  strides
 |      Tuple of bytes to step in each dimension when traversing an array.
 |      
 |      The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a`
 |      is::
 |      
 |          offset = sum(np.array(i) * a.strides)
 |      
 |      A more detailed explanation of strides can be found in the
 |      ""ndarray.rst"" file in the NumPy reference guide.
 |      
 |      Notes
 |      -----
 |      Imagine an array of 32-bit integers (each 4 bytes)::
 |      
 |        x = np.array([[0, 1, 2, 3, 4],
 |                      [5, 6, 7, 8, 9]], dtype=np.int32)
 |      
 |      This array is stored in memory as 40 bytes, one after the other
 |      (known as a contiguous block of memory).  The strides of an array tell
 |      us how many bytes we have to skip in memory to move to the next position
 |      along a certain axis.  For example, we have to skip 4 bytes (1 value) to
 |      move to the next column, but 20 bytes (5 values) to get to the same
 |      position in the next row.  As such, the strides for the array `x` will be
 |      ``(20, 4)``.
 |      
 |      See Also
 |      --------
 |      numpy.lib.stride_tricks.as_strided
 |      
 |      Examples
 |      --------
 |      >>> y = np.reshape(np.arange(2*3*4), (2,3,4))
 |      >>> y
 |      array([[[ 0,  1,  2,  3],
 |              [ 4,  5,  6,  7],
 |              [ 8,  9, 10, 11]],
 |             [[12, 13, 14, 15],
 |              [16, 17, 18, 19],
 |              [20, 21, 22, 23]]])
 |      >>> y.strides
 |      (48, 16, 4)
 |      >>> y[1,1,1]
 |      17
 |      >>> offset=sum(y.strides * np.array((1,1,1)))
 |      >>> offset/y.itemsize
 |      17
 |      
 |      >>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0)
 |      >>> x.strides
 |      (32, 4, 224, 1344)
 |      >>> i = np.array([3,5,2,2])
 |      >>> offset = sum(i * x.strides)
 |      >>> x[3,5,2,2]
 |      813
 |      >>> offset / x.itemsize
 |      813
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from numpy.ndarray:
 |  
 |  __hash__ = None
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.matlab.mio5.VarReader5,io.matlab.mio5,VarReader5,"Python Library Documentation: class VarReader5 in module scipy.io.matlab.mio5_utils

class VarReader5(builtins.object)
 |  Methods defined here:
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__ = __reduce_cython__(...)
 |  
 |  __setstate__ = __setstate_cython__(...)
 |  
 |  array_from_header(...)
 |      Read array of any class, given matrix `header`
 |      
 |      Parameters
 |      ----------
 |      header : VarHeader5
 |         array header object
 |      process : int, optional
 |         If not zero, apply post-processing on returned array
 |         
 |      Returns
 |      -------
 |      arr : array or sparse array
 |         read array
 |  
 |  read_cells(...)
 |      Read cell array from stream
 |  
 |  read_char(...)
 |      Read char matrices from stream as arrays
 |      
 |      Matrices of char are likely to be converted to matrices of
 |      string by later processing in ``array_from_header``
 |  
 |  read_fieldnames(...)
 |      Read fieldnames for struct-like matrix.
 |  
 |  read_full_tag(...)
 |      Python method for reading full u4, u4 tag from stream
 |      
 |      Returns
 |      -------
 |      mdtype : int32
 |         matlab data type code
 |      byte_count : int32
 |         number of data bytes following
 |      
 |      Notes
 |      -----
 |      Assumes tag is in fact full, that is, is not a small data
 |      element.  This means it can skip some checks and makes it
 |      slightly faster than ``read_tag``
 |  
 |  read_header(...)
 |      Return matrix header for current stream position
 |      
 |      Returns matrix headers at top level and sub levels
 |      
 |      Parameters
 |      ----------
 |      check_stream_limit : if True, then if the returned header
 |      is passed to array_from_header, it will be verified that
 |      the length of the uncompressed data is not overlong (which
 |      can indicate .mat file corruption)
 |  
 |  read_numeric(...)
 |      Read numeric data element into ndarray
 |      
 |      Reads element, then casts to ndarray.
 |      
 |      The type of the array is usually given by the ``mdtype`` returned via
 |      ``read_element``.  Sparse logical arrays are an exception, where the
 |      type of the array may be ``np.bool`` even if the ``mdtype`` claims the
 |      data is of float64 type.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          Whether to copy the array before returning.  If False, return array
 |          backed by bytes read from file.
 |      nnz : int, optional
 |          Number of non-zero values when reading numeric data from sparse
 |          matrices.  -1 if not reading sparse matrices, or to disable check
 |          for bytes data instead of declared data type (see Notes).
 |      
 |      Returns
 |      -------
 |      arr : array
 |          Numeric array
 |      
 |      Notes
 |      -----
 |      MATLAB apparently likes to store sparse logical matrix data as bytes
 |      instead of miDOUBLE (float64) data type, even though the data element
 |      still declares its type as miDOUBLE.  We can guess this has happened by
 |      looking for the length of the data compared to the expected number of
 |      elements, using the `nnz` input parameter.
 |  
 |  read_opaque(...)
 |      Read opaque (function workspace) type
 |      
 |      Looking at some mat files, the structure of this type seems to
 |      be:
 |      
 |      * array flags as usual (already read into `hdr`)
 |      * 3 int8 strings
 |      * a matrix
 |      
 |      Then there's a matrix at the end of the mat file that seems have
 |      the anonymous founction workspaces - we load it as
 |      ``__function_workspace__``
 |      
 |      See the comments at the beginning of ``mio5.py``
 |  
 |  read_real_complex(...)
 |      Read real / complex matrices from stream
 |  
 |  read_struct(...)
 |      Read struct or object array from stream
 |      
 |      Objects are just structs with an extra field *classname*,
 |      defined before (this here) struct format structure
 |  
 |  read_tag(...)
 |      Read tag mdtype and byte_count
 |      
 |      Does necessary swapping and takes account of SDE formats.
 |      
 |      See also ``read_full_tag`` method.
 |      
 |      Returns
 |      -------
 |      mdtype : int
 |         matlab data type code
 |      byte_count : int
 |         number of bytes following that comprise the data
 |      tag_data : None or str
 |         Any data from the tag itself.  This is None for a full tag,
 |         and string length `byte_count` if this is a small data
 |         element.
 |  
 |  set_stream(...)
 |      Set stream of best type from file-like `fobj`
 |      
 |      Called from Python when initiating a variable read
 |  
 |  shape_from_header(...)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  is_swapped
 |  
 |  little_endian
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __pyx_vtable__ = <capsule object NULL>
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.matlab.mio5.VarReader5,io.matlab.mio5,VarReader5,"Python Library Documentation: class VarReader5 in module scipy.io.matlab.mio5_utils

class VarReader5(builtins.object)
 |  Methods defined here:
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__ = __reduce_cython__(...)
 |  
 |  __setstate__ = __setstate_cython__(...)
 |  
 |  array_from_header(...)
 |      Read array of any class, given matrix `header`
 |      
 |      Parameters
 |      ----------
 |      header : VarHeader5
 |         array header object
 |      process : int, optional
 |         If not zero, apply post-processing on returned array
 |         
 |      Returns
 |      -------
 |      arr : array or sparse array
 |         read array
 |  
 |  read_cells(...)
 |      Read cell array from stream
 |  
 |  read_char(...)
 |      Read char matrices from stream as arrays
 |      
 |      Matrices of char are likely to be converted to matrices of
 |      string by later processing in ``array_from_header``
 |  
 |  read_fieldnames(...)
 |      Read fieldnames for struct-like matrix.
 |  
 |  read_full_tag(...)
 |      Python method for reading full u4, u4 tag from stream
 |      
 |      Returns
 |      -------
 |      mdtype : int32
 |         matlab data type code
 |      byte_count : int32
 |         number of data bytes following
 |      
 |      Notes
 |      -----
 |      Assumes tag is in fact full, that is, is not a small data
 |      element.  This means it can skip some checks and makes it
 |      slightly faster than ``read_tag``
 |  
 |  read_header(...)
 |      Return matrix header for current stream position
 |      
 |      Returns matrix headers at top level and sub levels
 |      
 |      Parameters
 |      ----------
 |      check_stream_limit : if True, then if the returned header
 |      is passed to array_from_header, it will be verified that
 |      the length of the uncompressed data is not overlong (which
 |      can indicate .mat file corruption)
 |  
 |  read_numeric(...)
 |      Read numeric data element into ndarray
 |      
 |      Reads element, then casts to ndarray.
 |      
 |      The type of the array is usually given by the ``mdtype`` returned via
 |      ``read_element``.  Sparse logical arrays are an exception, where the
 |      type of the array may be ``np.bool`` even if the ``mdtype`` claims the
 |      data is of float64 type.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          Whether to copy the array before returning.  If False, return array
 |          backed by bytes read from file.
 |      nnz : int, optional
 |          Number of non-zero values when reading numeric data from sparse
 |          matrices.  -1 if not reading sparse matrices, or to disable check
 |          for bytes data instead of declared data type (see Notes).
 |      
 |      Returns
 |      -------
 |      arr : array
 |          Numeric array
 |      
 |      Notes
 |      -----
 |      MATLAB apparently likes to store sparse logical matrix data as bytes
 |      instead of miDOUBLE (float64) data type, even though the data element
 |      still declares its type as miDOUBLE.  We can guess this has happened by
 |      looking for the length of the data compared to the expected number of
 |      elements, using the `nnz` input parameter.
 |  
 |  read_opaque(...)
 |      Read opaque (function workspace) type
 |      
 |      Looking at some mat files, the structure of this type seems to
 |      be:
 |      
 |      * array flags as usual (already read into `hdr`)
 |      * 3 int8 strings
 |      * a matrix
 |      
 |      Then there's a matrix at the end of the mat file that seems have
 |      the anonymous founction workspaces - we load it as
 |      ``__function_workspace__``
 |      
 |      See the comments at the beginning of ``mio5.py``
 |  
 |  read_real_complex(...)
 |      Read real / complex matrices from stream
 |  
 |  read_struct(...)
 |      Read struct or object array from stream
 |      
 |      Objects are just structs with an extra field *classname*,
 |      defined before (this here) struct format structure
 |  
 |  read_tag(...)
 |      Read tag mdtype and byte_count
 |      
 |      Does necessary swapping and takes account of SDE formats.
 |      
 |      See also ``read_full_tag`` method.
 |      
 |      Returns
 |      -------
 |      mdtype : int
 |         matlab data type code
 |      byte_count : int
 |         number of bytes following that comprise the data
 |      tag_data : None or str
 |         Any data from the tag itself.  This is None for a full tag,
 |         and string length `byte_count` if this is a small data
 |         element.
 |  
 |  set_stream(...)
 |      Set stream of best type from file-like `fobj`
 |      
 |      Called from Python when initiating a variable read
 |  
 |  shape_from_header(...)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  is_swapped
 |  
 |  little_endian
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __pyx_vtable__ = <capsule object NULL>
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.matlab.mio5.VarWriter5,io.matlab.mio5,VarWriter5,"Python Library Documentation: class VarWriter5 in module scipy.io.matlab.mio5

class VarWriter5(builtins.object)
 |  Generic matlab matrix writing class
 |  
 |  Methods defined here:
 |  
 |  __init__(self, file_writer)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  update_matrix_tag(self, start_pos)
 |  
 |  write(self, arr)
 |      Write `arr` to stream at top and sub levels
 |      
 |      Parameters
 |      ----------
 |      arr : array_like
 |          array-like object to create writer for
 |  
 |  write_bytes(self, arr)
 |  
 |  write_cells(self, arr)
 |  
 |  write_char(self, arr, codec='ascii')
 |      Write string array `arr` with given `codec`
 |  
 |  write_element(self, arr, mdtype=None)
 |      write tag and data
 |  
 |  write_empty_struct(self)
 |  
 |  write_header(self, shape, mclass, is_complex=False, is_logical=False, nzmax=0)
 |      Write header for given data options
 |      shape : sequence
 |         array shape
 |      mclass      - mat5 matrix class
 |      is_complex  - True if matrix is complex
 |      is_logical  - True if matrix is logical
 |      nzmax        - max non zero elements for sparse arrays
 |      
 |      We get the name and the global flag from the object, and reset
 |      them to defaults after we've used them
 |  
 |  write_numeric(self, arr)
 |  
 |  write_object(self, arr)
 |      Same as writing structs, except different mx class, and extra
 |      classname element after header
 |  
 |  write_regular_element(self, arr, mdtype, byte_count)
 |  
 |  write_smalldata_element(self, arr, mdtype, byte_count)
 |  
 |  write_sparse(self, arr)
 |      Sparse matrices are 2D
 |  
 |  write_string(self, s)
 |  
 |  write_struct(self, arr)
 |  
 |  write_top(self, arr, name, is_global)
 |      Write variable at top level of mat file
 |      
 |      Parameters
 |      ----------
 |      arr : array_like
 |          array-like object to create writer for
 |      name : str, optional
 |          name as it will appear in matlab workspace
 |          default is empty string
 |      is_global : {False, True}, optional
 |          whether variable will be global on load into matlab
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  mat_tag = array((14, 0), dtype=[('mdtype', '<u4'), ('byte_count', '<u4...
",class,"('(self, file_writer)',)",scipy,1.1.0,scipy.io.matlab.mio5.VarWriter5,io.matlab.mio5,VarWriter5,"Python Library Documentation: class VarWriter5 in module scipy.io.matlab.mio5

class VarWriter5(builtins.object)
 |  Generic matlab matrix writing class
 |  
 |  Methods defined here:
 |  
 |  __init__(self, file_writer)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  update_matrix_tag(self, start_pos)
 |  
 |  write(self, arr)
 |      Write `arr` to stream at top and sub levels
 |      
 |      Parameters
 |      ----------
 |      arr : array_like
 |          array-like object to create writer for
 |  
 |  write_bytes(self, arr)
 |  
 |  write_cells(self, arr)
 |  
 |  write_char(self, arr, codec='ascii')
 |      Write string array `arr` with given `codec`
 |  
 |  write_element(self, arr, mdtype=None)
 |      write tag and data
 |  
 |  write_empty_struct(self)
 |  
 |  write_header(self, shape, mclass, is_complex=False, is_logical=False, nzmax=0)
 |      Write header for given data options
 |      shape : sequence
 |         array shape
 |      mclass      - mat5 matrix class
 |      is_complex  - True if matrix is complex
 |      is_logical  - True if matrix is logical
 |      nzmax        - max non zero elements for sparse arrays
 |      
 |      We get the name and the global flag from the object, and reset
 |      them to defaults after we've used them
 |  
 |  write_numeric(self, arr)
 |  
 |  write_object(self, arr)
 |      Same as writing structs, except different mx class, and extra
 |      classname element after header
 |  
 |  write_regular_element(self, arr, mdtype, byte_count)
 |  
 |  write_smalldata_element(self, arr, mdtype, byte_count)
 |  
 |  write_sparse(self, arr)
 |      Sparse matrices are 2D
 |  
 |  write_string(self, s)
 |  
 |  write_struct(self, arr)
 |  
 |  write_top(self, arr, name, is_global)
 |      Write variable at top level of mat file
 |      
 |      Parameters
 |      ----------
 |      arr : array_like
 |          array-like object to create writer for
 |      name : str, optional
 |          name as it will appear in matlab workspace
 |          default is empty string
 |      is_global : {False, True}, optional
 |          whether variable will be global on load into matlab
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  mat_tag = array((14, 0), dtype=[('mdtype', '<u4'), ('byte_count', '<u4...
",class,"('self', 'file_writer')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(self, file_writer)',)"
scipy,1.1.0,scipy.io.matlab.mio5.ZlibInputStream,io.matlab.mio5,ZlibInputStream,"Python Library Documentation: class ZlibInputStream in module scipy.io.matlab.streams

class ZlibInputStream(GenericStream)
 |  File-like object uncompressing bytes from a zlib compressed stream.
 |  
 |  Parameters
 |  ----------
 |  stream : file-like
 |      Stream to read compressed data from.
 |  max_length : int
 |      Maximum number of bytes to read from the stream.
 |  
 |  Notes
 |  -----
 |  Some matlab files contain zlib streams without valid Z_STREAM_END
 |  termination.  To get round this, we use the decompressobj object, that
 |  allows you to decode an incomplete stream.  See discussion at
 |  http://bugs.python.org/issue8672
 |  
 |  Method resolution order:
 |      ZlibInputStream
 |      GenericStream
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__ = __reduce_cython__(...)
 |  
 |  __setstate__ = __setstate_cython__(...)
 |  
 |  all_data_read(...)
 |  
 |  read(...)
 |  
 |  seek(...)
 |  
 |  tell(...)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __pyx_vtable__ = <capsule object NULL>
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.matlab.mio5.ZlibInputStream,io.matlab.mio5,ZlibInputStream,"Python Library Documentation: class ZlibInputStream in module scipy.io.matlab.streams

class ZlibInputStream(GenericStream)
 |  File-like object uncompressing bytes from a zlib compressed stream.
 |  
 |  Parameters
 |  ----------
 |  stream : file-like
 |      Stream to read compressed data from.
 |  max_length : int
 |      Maximum number of bytes to read from the stream.
 |  
 |  Notes
 |  -----
 |  Some matlab files contain zlib streams without valid Z_STREAM_END
 |  termination.  To get round this, we use the decompressobj object, that
 |  allows you to decode an incomplete stream.  See discussion at
 |  http://bugs.python.org/issue8672
 |  
 |  Method resolution order:
 |      ZlibInputStream
 |      GenericStream
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__ = __reduce_cython__(...)
 |  
 |  __setstate__ = __setstate_cython__(...)
 |  
 |  all_data_read(...)
 |  
 |  read(...)
 |  
 |  seek(...)
 |  
 |  tell(...)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __pyx_vtable__ = <capsule object NULL>
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.matlab.mio5.arr_dtype_number,io.matlab.mio5,arr_dtype_number,"Python Library Documentation: function arr_dtype_number in module scipy.io.matlab.miobase

arr_dtype_number(arr, num)
    Return dtype for given number of items per element
",function,"('(arr, num)',)",scipy,1.1.0,scipy.io.matlab.mio5.arr_dtype_number,io.matlab.mio5,arr_dtype_number,"Python Library Documentation: function arr_dtype_number in module scipy.io.matlab.miobase

arr_dtype_number(arr, num)
    Return dtype for given number of items per element
",function,"('arr', 'num')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(arr, num)',)"
scipy,1.1.0,scipy.io.matlab.mio5.arr_to_chars,io.matlab.mio5,arr_to_chars,"Python Library Documentation: function arr_to_chars in module scipy.io.matlab.miobase

arr_to_chars(arr)
    Convert string array to char array
",function,"('(arr)',)",scipy,1.1.0,scipy.io.matlab.mio5.arr_to_chars,io.matlab.mio5,arr_to_chars,"Python Library Documentation: function arr_to_chars in module scipy.io.matlab.miobase

arr_to_chars(arr)
    Convert string array to char array
",function,"('arr',)","(nan,)","(nan,)","('arg_info',)","('(arr)',)"
scipy,1.1.0,scipy.io.matlab.mio5.asbytes,io.matlab.mio5,asbytes,"Python Library Documentation: function asbytes in module numpy.compat.py3k

asbytes(s)
",function,"('(s)',)",scipy,1.1.0,scipy.io.matlab.mio5.asbytes,io.matlab.mio5,asbytes,"Python Library Documentation: function asbytes in module numpy.compat.py3k

asbytes(s)
",function,"('s',)","(nan,)","(nan,)","('arg_info',)","('(s)',)"
scipy,1.1.0,scipy.io.matlab.mio5.asstr,io.matlab.mio5,asstr,"Python Library Documentation: function asstr in module numpy.compat.py3k

asstr(s)
",function,"('(s)',)",scipy,1.1.0,scipy.io.matlab.mio5.asstr,io.matlab.mio5,asstr,"Python Library Documentation: function asstr in module numpy.compat.py3k

asstr(s)
",function,"('s',)","(nan,)","(nan,)","('arg_info',)","('(s)',)"
scipy,1.1.0,scipy.io.matlab.mio5.docfiller,io.matlab.mio5,decorate,"Python Library Documentation: function decorate in module scipy.misc.doccer

decorate(f)
",function,"('(f)',)",scipy,1.1.0,scipy.io.matlab.mio5.docfiller,io.matlab.mio5,decorate,"Python Library Documentation: function decorate in module scipy.misc.doccer

decorate(f)
",function,"('f',)","(nan,)","(nan,)","('arg_info',)","('(f)',)"
scipy,1.1.0,scipy.io.matlab.mio5.matdims,io.matlab.mio5,matdims,"Python Library Documentation: function matdims in module scipy.io.matlab.miobase

matdims(arr, oned_as='column')
    Determine equivalent MATLAB dimensions for given array
    
    Parameters
    ----------
    arr : ndarray
        Input array
    oned_as : {'column', 'row'}, optional
        Whether 1-D arrays are returned as MATLAB row or column matrices.
        Default is 'column'.
    
    Returns
    -------
    dims : tuple
        Shape tuple, in the form MATLAB expects it.
    
    Notes
    -----
    We had to decide what shape a 1 dimensional array would be by
    default.  ``np.atleast_2d`` thinks it is a row vector.  The
    default for a vector in MATLAB (e.g. ``>> 1:12``) is a row vector.
    
    Versions of scipy up to and including 0.11 resulted (accidentally)
    in 1-D arrays being read as column vectors.  For the moment, we
    maintain the same tradition here.
    
    Examples
    --------
    >>> matdims(np.array(1)) # numpy scalar
    (1, 1)
    >>> matdims(np.array([1])) # 1d array, 1 element
    (1, 1)
    >>> matdims(np.array([1,2])) # 1d array, 2 elements
    (2, 1)
    >>> matdims(np.array([[2],[3]])) # 2d array, column vector
    (2, 1)
    >>> matdims(np.array([[2,3]])) # 2d array, row vector
    (1, 2)
    >>> matdims(np.array([[[2,3]]])) # 3d array, rowish vector
    (1, 1, 2)
    >>> matdims(np.array([])) # empty 1d array
    (0, 0)
    >>> matdims(np.array([[]])) # empty 2d
    (0, 0)
    >>> matdims(np.array([[[]]])) # empty 3d
    (0, 0, 0)
    
    Optional argument flips 1-D shape behavior.
    
    >>> matdims(np.array([1,2]), 'row') # 1d array, 2 elements
    (1, 2)
    
    The argument has to make sense though
    
    >>> matdims(np.array([1,2]), 'bizarre')
    Traceback (most recent call last):
       ...
    ValueError: 1D option ""bizarre"" is strange
",function,"(""(arr, oned_as='column')"",)",scipy,1.1.0,scipy.io.matlab.mio5.matdims,io.matlab.mio5,matdims,"Python Library Documentation: function matdims in module scipy.io.matlab.miobase

matdims(arr, oned_as='column')
    Determine equivalent MATLAB dimensions for given array
    
    Parameters
    ----------
    arr : ndarray
        Input array
    oned_as : {'column', 'row'}, optional
        Whether 1-D arrays are returned as MATLAB row or column matrices.
        Default is 'column'.
    
    Returns
    -------
    dims : tuple
        Shape tuple, in the form MATLAB expects it.
    
    Notes
    -----
    We had to decide what shape a 1 dimensional array would be by
    default.  ``np.atleast_2d`` thinks it is a row vector.  The
    default for a vector in MATLAB (e.g. ``>> 1:12``) is a row vector.
    
    Versions of scipy up to and including 0.11 resulted (accidentally)
    in 1-D arrays being read as column vectors.  For the moment, we
    maintain the same tradition here.
    
    Examples
    --------
    >>> matdims(np.array(1)) # numpy scalar
    (1, 1)
    >>> matdims(np.array([1])) # 1d array, 1 element
    (1, 1)
    >>> matdims(np.array([1,2])) # 1d array, 2 elements
    (2, 1)
    >>> matdims(np.array([[2],[3]])) # 2d array, column vector
    (2, 1)
    >>> matdims(np.array([[2,3]])) # 2d array, row vector
    (1, 2)
    >>> matdims(np.array([[[2,3]]])) # 3d array, rowish vector
    (1, 1, 2)
    >>> matdims(np.array([])) # empty 1d array
    (0, 0)
    >>> matdims(np.array([[]])) # empty 2d
    (0, 0)
    >>> matdims(np.array([[[]]])) # empty 3d
    (0, 0, 0)
    
    Optional argument flips 1-D shape behavior.
    
    >>> matdims(np.array([1,2]), 'row') # 1d array, 2 elements
    (1, 2)
    
    The argument has to make sense though
    
    >>> matdims(np.array([1,2]), 'bizarre')
    Traceback (most recent call last):
       ...
    ValueError: 1D option ""bizarre"" is strange
",function,"('arr', 'oned_as')","(nan, 'column')","(nan, 'str')","('arg_info', 'arg_info')","(""(arr, oned_as='column')"",)"
scipy,1.1.0,scipy.io.matlab.mio5.read_dtype,io.matlab.mio5,read_dtype,"Python Library Documentation: function read_dtype in module scipy.io.matlab.miobase

read_dtype(mat_stream, a_dtype)
    Generic get of byte stream data of known type
    
    Parameters
    ----------
    mat_stream : file_like object
        MATLAB (tm) mat file stream
    a_dtype : dtype
        dtype of array to read.  `a_dtype` is assumed to be correct
        endianness.
    
    Returns
    -------
    arr : ndarray
        Array of dtype `a_dtype` read from stream.
",function,"('(mat_stream, a_dtype)',)",scipy,1.1.0,scipy.io.matlab.mio5.read_dtype,io.matlab.mio5,read_dtype,"Python Library Documentation: function read_dtype in module scipy.io.matlab.miobase

read_dtype(mat_stream, a_dtype)
    Generic get of byte stream data of known type
    
    Parameters
    ----------
    mat_stream : file_like object
        MATLAB (tm) mat file stream
    a_dtype : dtype
        dtype of array to read.  `a_dtype` is assumed to be correct
        endianness.
    
    Returns
    -------
    arr : ndarray
        Array of dtype `a_dtype` read from stream.
",function,"('mat_stream', 'a_dtype')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(mat_stream, a_dtype)',)"
scipy,1.1.0,scipy.io.matlab.mio5.to_writeable,io.matlab.mio5,to_writeable,"Python Library Documentation: function to_writeable in module scipy.io.matlab.mio5

to_writeable(source)
    Convert input object ``source`` to something we can write
    
    Parameters
    ----------
    source : object
    
    Returns
    -------
    arr : None or ndarray or EmptyStructMarker
        If `source` cannot be converted to something we can write to a matfile,
        return None.  If `source` is equivalent to an empty dictionary, return
        ``EmptyStructMarker``.  Otherwise return `source` converted to an
        ndarray with contents for writing to matfile.
",function,"('(source)',)",scipy,1.1.0,scipy.io.matlab.mio5.to_writeable,io.matlab.mio5,to_writeable,"Python Library Documentation: function to_writeable in module scipy.io.matlab.mio5

to_writeable(source)
    Convert input object ``source`` to something we can write
    
    Parameters
    ----------
    source : object
    
    Returns
    -------
    arr : None or ndarray or EmptyStructMarker
        If `source` cannot be converted to something we can write to a matfile,
        return None.  If `source` is equivalent to an empty dictionary, return
        ``EmptyStructMarker``.  Otherwise return `source` converted to an
        ndarray with contents for writing to matfile.
",function,"('source',)","(nan,)","(nan,)","('arg_info',)","('(source)',)"
scipy,1.1.0,scipy.io.matlab.mio5.varmats_from_mat,io.matlab.mio5,varmats_from_mat,"Python Library Documentation: function varmats_from_mat in module scipy.io.matlab.mio5

varmats_from_mat(file_obj)
    Pull variables out of mat 5 file as a sequence of mat file objects
    
    This can be useful with a difficult mat file, containing unreadable
    variables.  This routine pulls the variables out in raw form and puts them,
    unread, back into a file stream for saving or reading.  Another use is the
    pathological case where there is more than one variable of the same name in
    the file; this routine returns the duplicates, whereas the standard reader
    will overwrite duplicates in the returned dictionary.
    
    The file pointer in `file_obj` will be undefined.  File pointers for the
    returned file-like objects are set at 0.
    
    Parameters
    ----------
    file_obj : file-like
        file object containing mat file
    
    Returns
    -------
    named_mats : list
        list contains tuples of (name, BytesIO) where BytesIO is a file-like
        object containing mat file contents as for a single variable.  The
        BytesIO contains a string with the original header and a single var. If
        ``var_file_obj`` is an individual BytesIO instance, then save as a mat
        file with something like ``open('test.mat',
        'wb').write(var_file_obj.read())``
    
    Examples
    --------
    >>> import scipy.io
    
    BytesIO is from the ``io`` module in python 3, and is ``cStringIO`` for
    python < 3.
    
    >>> mat_fileobj = BytesIO()
    >>> scipy.io.savemat(mat_fileobj, {'b': np.arange(10), 'a': 'a string'})
    >>> varmats = varmats_from_mat(mat_fileobj)
    >>> sorted([name for name, str_obj in varmats])
    ['a', 'b']
",function,"('(file_obj)',)",scipy,1.1.0,scipy.io.matlab.mio5.varmats_from_mat,io.matlab.mio5,varmats_from_mat,"Python Library Documentation: function varmats_from_mat in module scipy.io.matlab.mio5

varmats_from_mat(file_obj)
    Pull variables out of mat 5 file as a sequence of mat file objects
    
    This can be useful with a difficult mat file, containing unreadable
    variables.  This routine pulls the variables out in raw form and puts them,
    unread, back into a file stream for saving or reading.  Another use is the
    pathological case where there is more than one variable of the same name in
    the file; this routine returns the duplicates, whereas the standard reader
    will overwrite duplicates in the returned dictionary.
    
    The file pointer in `file_obj` will be undefined.  File pointers for the
    returned file-like objects are set at 0.
    
    Parameters
    ----------
    file_obj : file-like
        file object containing mat file
    
    Returns
    -------
    named_mats : list
        list contains tuples of (name, BytesIO) where BytesIO is a file-like
        object containing mat file contents as for a single variable.  The
        BytesIO contains a string with the original header and a single var. If
        ``var_file_obj`` is an individual BytesIO instance, then save as a mat
        file with something like ``open('test.mat',
        'wb').write(var_file_obj.read())``
    
    Examples
    --------
    >>> import scipy.io
    
    BytesIO is from the ``io`` module in python 3, and is ``cStringIO`` for
    python < 3.
    
    >>> mat_fileobj = BytesIO()
    >>> scipy.io.savemat(mat_fileobj, {'b': np.arange(10), 'a': 'a string'})
    >>> varmats = varmats_from_mat(mat_fileobj)
    >>> sorted([name for name, str_obj in varmats])
    ['a', 'b']
",function,"('file_obj',)","(nan,)","(nan,)","('arg_info',)","('(file_obj)',)"
scipy,1.1.0,scipy.io.matlab.mio5_params.MatlabFunction,io.matlab.mio5_params,MatlabFunction,"Python Library Documentation: class MatlabFunction in module scipy.io.matlab.mio5_params

class MatlabFunction(numpy.ndarray)
 |  Subclass to signal this is a matlab function
 |  
 |  Method resolution order:
 |      MatlabFunction
 |      numpy.ndarray
 |      builtins.object
 |  
 |  Static methods defined here:
 |  
 |  __new__(cls, input_array)
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from numpy.ndarray:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __array__(...)
 |      a.__array__(|dtype) -> reference if type unchanged, copy otherwise.
 |      
 |      Returns either a new reference to self if dtype is not given or a new array
 |      of provided data type if dtype is different from the current dtype of the
 |      array.
 |  
 |  __array_prepare__(...)
 |      a.__array_prepare__(obj) -> Object of same type as ndarray object obj.
 |  
 |  __array_ufunc__(...)
 |  
 |  __array_wrap__(...)
 |      a.__array_wrap__(obj) -> Object of same type as ndarray object a.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __complex__(...)
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __copy__(...)
 |      a.__copy__()
 |      
 |      Used if :func:`copy.copy` is called on an array. Returns a copy of the array.
 |      
 |      Equivalent to ``a.copy(order='K')``.
 |  
 |  __deepcopy__(...)
 |      a.__deepcopy__(memo, /) -> Deep copy of array.
 |      
 |      Used if :func:`copy.deepcopy` is called on an array.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __format__(...)
 |      default object formatter
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iadd__(self, value, /)
 |      Return self+=value.
 |  
 |  __iand__(self, value, /)
 |      Return self&=value.
 |  
 |  __ifloordiv__(self, value, /)
 |      Return self//=value.
 |  
 |  __ilshift__(self, value, /)
 |      Return self<<=value.
 |  
 |  __imatmul__(self, value, /)
 |      Return self@=value.
 |  
 |  __imod__(self, value, /)
 |      Return self%=value.
 |  
 |  __imul__(self, value, /)
 |      Return self*=value.
 |  
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __ior__(self, value, /)
 |      Return self|=value.
 |  
 |  __ipow__(self, value, /)
 |      Return self**=value.
 |  
 |  __irshift__(self, value, /)
 |      Return self>>=value.
 |  
 |  __isub__(self, value, /)
 |      Return self-=value.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __itruediv__(self, value, /)
 |      Return self/=value.
 |  
 |  __ixor__(self, value, /)
 |      Return self^=value.
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __matmul__(self, value, /)
 |      Return self@value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __reduce__(...)
 |      a.__reduce__()
 |      
 |      For pickling.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmatmul__(self, value, /)
 |      Return value@self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __setstate__(...)
 |      a.__setstate__(state, /)
 |      
 |      For unpickling.
 |      
 |      The `state` argument must be a sequence that contains the following
 |      elements:
 |      
 |      Parameters
 |      ----------
 |      version : int
 |          optional pickle version. If omitted defaults to 0.
 |      shape : tuple
 |      dtype : data-type
 |      isFortran : bool
 |      rawdata : string or list
 |          a binary string with the data (or a list if 'a' is an object array)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  all(...)
 |      a.all(axis=None, out=None, keepdims=False)
 |      
 |      Returns True if all elements evaluate to True.
 |      
 |      Refer to `numpy.all` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.all : equivalent function
 |  
 |  any(...)
 |      a.any(axis=None, out=None, keepdims=False)
 |      
 |      Returns True if any of the elements of `a` evaluate to True.
 |      
 |      Refer to `numpy.any` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.any : equivalent function
 |  
 |  argmax(...)
 |      a.argmax(axis=None, out=None)
 |      
 |      Return indices of the maximum values along the given axis.
 |      
 |      Refer to `numpy.argmax` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argmax : equivalent function
 |  
 |  argmin(...)
 |      a.argmin(axis=None, out=None)
 |      
 |      Return indices of the minimum values along the given axis of `a`.
 |      
 |      Refer to `numpy.argmin` for detailed documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argmin : equivalent function
 |  
 |  argpartition(...)
 |      a.argpartition(kth, axis=-1, kind='introselect', order=None)
 |      
 |      Returns the indices that would partition this array.
 |      
 |      Refer to `numpy.argpartition` for full documentation.
 |      
 |      .. versionadded:: 1.8.0
 |      
 |      See Also
 |      --------
 |      numpy.argpartition : equivalent function
 |  
 |  argsort(...)
 |      a.argsort(axis=-1, kind='quicksort', order=None)
 |      
 |      Returns the indices that would sort this array.
 |      
 |      Refer to `numpy.argsort` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argsort : equivalent function
 |  
 |  astype(...)
 |      a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)
 |      
 |      Copy of the array, cast to a specified type.
 |      
 |      Parameters
 |      ----------
 |      dtype : str or dtype
 |          Typecode or data-type to which the array is cast.
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          Controls the memory layout order of the result.
 |          'C' means C order, 'F' means Fortran order, 'A'
 |          means 'F' order if all the arrays are Fortran contiguous,
 |          'C' order otherwise, and 'K' means as close to the
 |          order the array elements appear in memory as possible.
 |          Default is 'K'.
 |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
 |          Controls what kind of data casting may occur. Defaults to 'unsafe'
 |          for backwards compatibility.
 |      
 |            * 'no' means the data types should not be cast at all.
 |            * 'equiv' means only byte-order changes are allowed.
 |            * 'safe' means only casts which can preserve values are allowed.
 |            * 'same_kind' means only safe casts or casts within a kind,
 |              like float64 to float32, are allowed.
 |            * 'unsafe' means any data conversions may be done.
 |      subok : bool, optional
 |          If True, then sub-classes will be passed-through (default), otherwise
 |          the returned array will be forced to be a base-class array.
 |      copy : bool, optional
 |          By default, astype always returns a newly allocated array. If this
 |          is set to false, and the `dtype`, `order`, and `subok`
 |          requirements are satisfied, the input array is returned instead
 |          of a copy.
 |      
 |      Returns
 |      -------
 |      arr_t : ndarray
 |          Unless `copy` is False and the other conditions for returning the input
 |          array are satisfied (see description for `copy` input parameter), `arr_t`
 |          is a new array of the same shape as the input array, with dtype, order
 |          given by `dtype`, `order`.
 |      
 |      Notes
 |      -----
 |      Starting in NumPy 1.9, astype method now returns an error if the string
 |      dtype to cast to is not long enough in 'safe' casting mode to hold the max
 |      value of integer/float array that is being casted. Previously the casting
 |      was allowed even if the result was truncated.
 |      
 |      Raises
 |      ------
 |      ComplexWarning
 |          When casting from complex to float or int. To avoid this,
 |          one should use ``a.real.astype(t)``.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 2.5])
 |      >>> x
 |      array([ 1. ,  2. ,  2.5])
 |      
 |      >>> x.astype(int)
 |      array([1, 2, 2])
 |  
 |  byteswap(...)
 |      a.byteswap(inplace=False)
 |      
 |      Swap the bytes of the array elements
 |      
 |      Toggle between low-endian and big-endian data representation by
 |      returning a byteswapped array, optionally swapped in-place.
 |      
 |      Parameters
 |      ----------
 |      inplace : bool, optional
 |          If ``True``, swap bytes in-place, default is ``False``.
 |      
 |      Returns
 |      -------
 |      out : ndarray
 |          The byteswapped array. If `inplace` is ``True``, this is
 |          a view to self.
 |      
 |      Examples
 |      --------
 |      >>> A = np.array([1, 256, 8755], dtype=np.int16)
 |      >>> map(hex, A)
 |      ['0x1', '0x100', '0x2233']
 |      >>> A.byteswap(inplace=True)
 |      array([  256,     1, 13090], dtype=int16)
 |      >>> map(hex, A)
 |      ['0x100', '0x1', '0x3322']
 |      
 |      Arrays of strings are not swapped
 |      
 |      >>> A = np.array(['ceg', 'fac'])
 |      >>> A.byteswap()
 |      array(['ceg', 'fac'],
 |            dtype='|S3')
 |  
 |  choose(...)
 |      a.choose(choices, out=None, mode='raise')
 |      
 |      Use an index array to construct a new array from a set of choices.
 |      
 |      Refer to `numpy.choose` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.choose : equivalent function
 |  
 |  clip(...)
 |      a.clip(min=None, max=None, out=None)
 |      
 |      Return an array whose values are limited to ``[min, max]``.
 |      One of max or min must be given.
 |      
 |      Refer to `numpy.clip` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.clip : equivalent function
 |  
 |  compress(...)
 |      a.compress(condition, axis=None, out=None)
 |      
 |      Return selected slices of this array along given axis.
 |      
 |      Refer to `numpy.compress` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.compress : equivalent function
 |  
 |  conj(...)
 |      a.conj()
 |      
 |      Complex-conjugate all elements.
 |      
 |      Refer to `numpy.conjugate` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.conjugate : equivalent function
 |  
 |  conjugate(...)
 |      a.conjugate()
 |      
 |      Return the complex conjugate, element-wise.
 |      
 |      Refer to `numpy.conjugate` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.conjugate : equivalent function
 |  
 |  copy(...)
 |      a.copy(order='C')
 |      
 |      Return a copy of the array.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          Controls the memory layout of the copy. 'C' means C-order,
 |          'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
 |          'C' otherwise. 'K' means match the layout of `a` as closely
 |          as possible. (Note that this function and :func:`numpy.copy` are very
 |          similar, but have different default values for their order=
 |          arguments.)
 |      
 |      See also
 |      --------
 |      numpy.copy
 |      numpy.copyto
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[1,2,3],[4,5,6]], order='F')
 |      
 |      >>> y = x.copy()
 |      
 |      >>> x.fill(0)
 |      
 |      >>> x
 |      array([[0, 0, 0],
 |             [0, 0, 0]])
 |      
 |      >>> y
 |      array([[1, 2, 3],
 |             [4, 5, 6]])
 |      
 |      >>> y.flags['C_CONTIGUOUS']
 |      True
 |  
 |  cumprod(...)
 |      a.cumprod(axis=None, dtype=None, out=None)
 |      
 |      Return the cumulative product of the elements along the given axis.
 |      
 |      Refer to `numpy.cumprod` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.cumprod : equivalent function
 |  
 |  cumsum(...)
 |      a.cumsum(axis=None, dtype=None, out=None)
 |      
 |      Return the cumulative sum of the elements along the given axis.
 |      
 |      Refer to `numpy.cumsum` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.cumsum : equivalent function
 |  
 |  diagonal(...)
 |      a.diagonal(offset=0, axis1=0, axis2=1)
 |      
 |      Return specified diagonals. In NumPy 1.9 the returned array is a
 |      read-only view instead of a copy as in previous NumPy versions.  In
 |      a future version the read-only restriction will be removed.
 |      
 |      Refer to :func:`numpy.diagonal` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.diagonal : equivalent function
 |  
 |  dot(...)
 |      a.dot(b, out=None)
 |      
 |      Dot product of two arrays.
 |      
 |      Refer to `numpy.dot` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.dot : equivalent function
 |      
 |      Examples
 |      --------
 |      >>> a = np.eye(2)
 |      >>> b = np.ones((2, 2)) * 2
 |      >>> a.dot(b)
 |      array([[ 2.,  2.],
 |             [ 2.,  2.]])
 |      
 |      This array method can be conveniently chained:
 |      
 |      >>> a.dot(b).dot(b)
 |      array([[ 8.,  8.],
 |             [ 8.,  8.]])
 |  
 |  dump(...)
 |      a.dump(file)
 |      
 |      Dump a pickle of the array to the specified file.
 |      The array can be read back with pickle.load or numpy.load.
 |      
 |      Parameters
 |      ----------
 |      file : str
 |          A string naming the dump file.
 |  
 |  dumps(...)
 |      a.dumps()
 |      
 |      Returns the pickle of the array as a string.
 |      pickle.loads or numpy.loads will convert the string back to an array.
 |      
 |      Parameters
 |      ----------
 |      None
 |  
 |  fill(...)
 |      a.fill(value)
 |      
 |      Fill the array with a scalar value.
 |      
 |      Parameters
 |      ----------
 |      value : scalar
 |          All elements of `a` will be assigned this value.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([1, 2])
 |      >>> a.fill(0)
 |      >>> a
 |      array([0, 0])
 |      >>> a = np.empty(2)
 |      >>> a.fill(1)
 |      >>> a
 |      array([ 1.,  1.])
 |  
 |  flatten(...)
 |      a.flatten(order='C')
 |      
 |      Return a copy of the array collapsed into one dimension.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          'C' means to flatten in row-major (C-style) order.
 |          'F' means to flatten in column-major (Fortran-
 |          style) order. 'A' means to flatten in column-major
 |          order if `a` is Fortran *contiguous* in memory,
 |          row-major order otherwise. 'K' means to flatten
 |          `a` in the order the elements occur in memory.
 |          The default is 'C'.
 |      
 |      Returns
 |      -------
 |      y : ndarray
 |          A copy of the input array, flattened to one dimension.
 |      
 |      See Also
 |      --------
 |      ravel : Return a flattened array.
 |      flat : A 1-D flat iterator over the array.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1,2], [3,4]])
 |      >>> a.flatten()
 |      array([1, 2, 3, 4])
 |      >>> a.flatten('F')
 |      array([1, 3, 2, 4])
 |  
 |  getfield(...)
 |      a.getfield(dtype, offset=0)
 |      
 |      Returns a field of the given array as a certain type.
 |      
 |      A field is a view of the array data with a given data-type. The values in
 |      the view are determined by the given type and the offset into the current
 |      array in bytes. The offset needs to be such that the view dtype fits in the
 |      array dtype; for example an array of dtype complex128 has 16-byte elements.
 |      If taking a view with a 32-bit integer (4 bytes), the offset needs to be
 |      between 0 and 12 bytes.
 |      
 |      Parameters
 |      ----------
 |      dtype : str or dtype
 |          The data type of the view. The dtype size of the view can not be larger
 |          than that of the array itself.
 |      offset : int
 |          Number of bytes to skip before beginning the element view.
 |      
 |      Examples
 |      --------
 |      >>> x = np.diag([1.+1.j]*2)
 |      >>> x[1, 1] = 2 + 4.j
 |      >>> x
 |      array([[ 1.+1.j,  0.+0.j],
 |             [ 0.+0.j,  2.+4.j]])
 |      >>> x.getfield(np.float64)
 |      array([[ 1.,  0.],
 |             [ 0.,  2.]])
 |      
 |      By choosing an offset of 8 bytes we can select the complex part of the
 |      array for our view:
 |      
 |      >>> x.getfield(np.float64, offset=8)
 |      array([[ 1.,  0.],
 |         [ 0.,  4.]])
 |  
 |  item(...)
 |      a.item(*args)
 |      
 |      Copy an element of an array to a standard Python scalar and return it.
 |      
 |      Parameters
 |      ----------
 |      \*args : Arguments (variable number and type)
 |      
 |          * none: in this case, the method only works for arrays
 |            with one element (`a.size == 1`), which element is
 |            copied into a standard Python scalar object and returned.
 |      
 |          * int_type: this argument is interpreted as a flat index into
 |            the array, specifying which element to copy and return.
 |      
 |          * tuple of int_types: functions as does a single int_type argument,
 |            except that the argument is interpreted as an nd-index into the
 |            array.
 |      
 |      Returns
 |      -------
 |      z : Standard Python scalar object
 |          A copy of the specified element of the array as a suitable
 |          Python scalar
 |      
 |      Notes
 |      -----
 |      When the data type of `a` is longdouble or clongdouble, item() returns
 |      a scalar array object because there is no available Python scalar that
 |      would not lose information. Void arrays return a buffer object for item(),
 |      unless fields are defined, in which case a tuple is returned.
 |      
 |      `item` is very similar to a[args], except, instead of an array scalar,
 |      a standard Python scalar is returned. This can be useful for speeding up
 |      access to elements of the array and doing arithmetic on elements of the
 |      array using Python's optimized math.
 |      
 |      Examples
 |      --------
 |      >>> x = np.random.randint(9, size=(3, 3))
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 8, 3],
 |             [8, 5, 3]])
 |      >>> x.item(3)
 |      2
 |      >>> x.item(7)
 |      5
 |      >>> x.item((0, 1))
 |      1
 |      >>> x.item((2, 2))
 |      3
 |  
 |  itemset(...)
 |      a.itemset(*args)
 |      
 |      Insert scalar into an array (scalar is cast to array's dtype, if possible)
 |      
 |      There must be at least 1 argument, and define the last argument
 |      as *item*.  Then, ``a.itemset(*args)`` is equivalent to but faster
 |      than ``a[args] = item``.  The item should be a scalar value and `args`
 |      must select a single item in the array `a`.
 |      
 |      Parameters
 |      ----------
 |      \*args : Arguments
 |          If one argument: a scalar, only used in case `a` is of size 1.
 |          If two arguments: the last argument is the value to be set
 |          and must be a scalar, the first argument specifies a single array
 |          element location. It is either an int or a tuple.
 |      
 |      Notes
 |      -----
 |      Compared to indexing syntax, `itemset` provides some speed increase
 |      for placing a scalar into a particular location in an `ndarray`,
 |      if you must do this.  However, generally this is discouraged:
 |      among other problems, it complicates the appearance of the code.
 |      Also, when using `itemset` (and `item`) inside a loop, be sure
 |      to assign the methods to a local variable to avoid the attribute
 |      look-up at each loop iteration.
 |      
 |      Examples
 |      --------
 |      >>> x = np.random.randint(9, size=(3, 3))
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 8, 3],
 |             [8, 5, 3]])
 |      >>> x.itemset(4, 0)
 |      >>> x.itemset((2, 2), 9)
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 0, 3],
 |             [8, 5, 9]])
 |  
 |  max(...)
 |      a.max(axis=None, out=None, keepdims=False)
 |      
 |      Return the maximum along a given axis.
 |      
 |      Refer to `numpy.amax` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.amax : equivalent function
 |  
 |  mean(...)
 |      a.mean(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Returns the average of the array elements along given axis.
 |      
 |      Refer to `numpy.mean` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.mean : equivalent function
 |  
 |  min(...)
 |      a.min(axis=None, out=None, keepdims=False)
 |      
 |      Return the minimum along a given axis.
 |      
 |      Refer to `numpy.amin` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.amin : equivalent function
 |  
 |  newbyteorder(...)
 |      arr.newbyteorder(new_order='S')
 |      
 |      Return the array with the same data viewed with a different byte order.
 |      
 |      Equivalent to::
 |      
 |          arr.view(arr.dtype.newbytorder(new_order))
 |      
 |      Changes are also made in all fields and sub-arrays of the array data
 |      type.
 |      
 |      
 |      
 |      Parameters
 |      ----------
 |      new_order : string, optional
 |          Byte order to force; a value from the byte order specifications
 |          below. `new_order` codes can be any of:
 |      
 |          * 'S' - swap dtype from current to opposite endian
 |          * {'<', 'L'} - little endian
 |          * {'>', 'B'} - big endian
 |          * {'=', 'N'} - native order
 |          * {'|', 'I'} - ignore (no change to byte order)
 |      
 |          The default value ('S') results in swapping the current
 |          byte order. The code does a case-insensitive check on the first
 |          letter of `new_order` for the alternatives above.  For example,
 |          any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 |      
 |      
 |      Returns
 |      -------
 |      new_arr : array
 |          New array object with the dtype reflecting given change to the
 |          byte order.
 |  
 |  nonzero(...)
 |      a.nonzero()
 |      
 |      Return the indices of the elements that are non-zero.
 |      
 |      Refer to `numpy.nonzero` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.nonzero : equivalent function
 |  
 |  partition(...)
 |      a.partition(kth, axis=-1, kind='introselect', order=None)
 |      
 |      Rearranges the elements in the array in such a way that value of the
 |      element in kth position is in the position it would be in a sorted array.
 |      All elements smaller than the kth element are moved before this element and
 |      all equal or greater are moved behind it. The ordering of the elements in
 |      the two partitions is undefined.
 |      
 |      .. versionadded:: 1.8.0
 |      
 |      Parameters
 |      ----------
 |      kth : int or sequence of ints
 |          Element index to partition by. The kth element value will be in its
 |          final sorted position and all smaller elements will be moved before it
 |          and all equal or greater elements behind it.
 |          The order all elements in the partitions is undefined.
 |          If provided with a sequence of kth it will partition all elements
 |          indexed by kth of them into their sorted position at once.
 |      axis : int, optional
 |          Axis along which to sort. Default is -1, which means sort along the
 |          last axis.
 |      kind : {'introselect'}, optional
 |          Selection algorithm. Default is 'introselect'.
 |      order : str or list of str, optional
 |          When `a` is an array with fields defined, this argument specifies
 |          which fields to compare first, second, etc.  A single field can
 |          be specified as a string, and not all fields need be specified,
 |          but unspecified fields will still be used, in the order in which
 |          they come up in the dtype, to break ties.
 |      
 |      See Also
 |      --------
 |      numpy.partition : Return a parititioned copy of an array.
 |      argpartition : Indirect partition.
 |      sort : Full sort.
 |      
 |      Notes
 |      -----
 |      See ``np.partition`` for notes on the different algorithms.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([3, 4, 2, 1])
 |      >>> a.partition(3)
 |      >>> a
 |      array([2, 1, 3, 4])
 |      
 |      >>> a.partition((1, 3))
 |      array([1, 2, 3, 4])
 |  
 |  prod(...)
 |      a.prod(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Return the product of the array elements over the given axis
 |      
 |      Refer to `numpy.prod` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.prod : equivalent function
 |  
 |  ptp(...)
 |      a.ptp(axis=None, out=None)
 |      
 |      Peak to peak (maximum - minimum) value along a given axis.
 |      
 |      Refer to `numpy.ptp` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.ptp : equivalent function
 |  
 |  put(...)
 |      a.put(indices, values, mode='raise')
 |      
 |      Set ``a.flat[n] = values[n]`` for all `n` in indices.
 |      
 |      Refer to `numpy.put` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.put : equivalent function
 |  
 |  ravel(...)
 |      a.ravel([order])
 |      
 |      Return a flattened array.
 |      
 |      Refer to `numpy.ravel` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.ravel : equivalent function
 |      
 |      ndarray.flat : a flat iterator on the array.
 |  
 |  repeat(...)
 |      a.repeat(repeats, axis=None)
 |      
 |      Repeat elements of an array.
 |      
 |      Refer to `numpy.repeat` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.repeat : equivalent function
 |  
 |  reshape(...)
 |      a.reshape(shape, order='C')
 |      
 |      Returns an array containing the same data with a new shape.
 |      
 |      Refer to `numpy.reshape` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.reshape : equivalent function
 |      
 |      Notes
 |      -----
 |      Unlike the free function `numpy.reshape`, this method on `ndarray` allows
 |      the elements of the shape parameter to be passed in as separate arguments.
 |      For example, ``a.reshape(10, 11)`` is equivalent to
 |      ``a.reshape((10, 11))``.
 |  
 |  resize(...)
 |      a.resize(new_shape, refcheck=True)
 |      
 |      Change shape and size of array in-place.
 |      
 |      Parameters
 |      ----------
 |      new_shape : tuple of ints, or `n` ints
 |          Shape of resized array.
 |      refcheck : bool, optional
 |          If False, reference count will not be checked. Default is True.
 |      
 |      Returns
 |      -------
 |      None
 |      
 |      Raises
 |      ------
 |      ValueError
 |          If `a` does not own its own data or references or views to it exist,
 |          and the data memory must be changed.
 |          PyPy only: will always raise if the data memory must be changed, since
 |          there is no reliable way to determine if references or views to it
 |          exist.
 |      
 |      SystemError
 |          If the `order` keyword argument is specified. This behaviour is a
 |          bug in NumPy.
 |      
 |      See Also
 |      --------
 |      resize : Return a new array with the specified shape.
 |      
 |      Notes
 |      -----
 |      This reallocates space for the data area if necessary.
 |      
 |      Only contiguous arrays (data elements consecutive in memory) can be
 |      resized.
 |      
 |      The purpose of the reference count check is to make sure you
 |      do not use this array as a buffer for another Python object and then
 |      reallocate the memory. However, reference counts can increase in
 |      other ways so if you are sure that you have not shared the memory
 |      for this array with another Python object, then you may safely set
 |      `refcheck` to False.
 |      
 |      Examples
 |      --------
 |      Shrinking an array: array is flattened (in the order that the data are
 |      stored in memory), resized, and reshaped:
 |      
 |      >>> a = np.array([[0, 1], [2, 3]], order='C')
 |      >>> a.resize((2, 1))
 |      >>> a
 |      array([[0],
 |             [1]])
 |      
 |      >>> a = np.array([[0, 1], [2, 3]], order='F')
 |      >>> a.resize((2, 1))
 |      >>> a
 |      array([[0],
 |             [2]])
 |      
 |      Enlarging an array: as above, but missing entries are filled with zeros:
 |      
 |      >>> b = np.array([[0, 1], [2, 3]])
 |      >>> b.resize(2, 3) # new_shape parameter doesn't have to be a tuple
 |      >>> b
 |      array([[0, 1, 2],
 |             [3, 0, 0]])
 |      
 |      Referencing an array prevents resizing...
 |      
 |      >>> c = a
 |      >>> a.resize((1, 1))
 |      Traceback (most recent call last):
 |      ...
 |      ValueError: cannot resize an array that has been referenced ...
 |      
 |      Unless `refcheck` is False:
 |      
 |      >>> a.resize((1, 1), refcheck=False)
 |      >>> a
 |      array([[0]])
 |      >>> c
 |      array([[0]])
 |  
 |  round(...)
 |      a.round(decimals=0, out=None)
 |      
 |      Return `a` with each element rounded to the given number of decimals.
 |      
 |      Refer to `numpy.around` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.around : equivalent function
 |  
 |  searchsorted(...)
 |      a.searchsorted(v, side='left', sorter=None)
 |      
 |      Find indices where elements of v should be inserted in a to maintain order.
 |      
 |      For full documentation, see `numpy.searchsorted`
 |      
 |      See Also
 |      --------
 |      numpy.searchsorted : equivalent function
 |  
 |  setfield(...)
 |      a.setfield(val, dtype, offset=0)
 |      
 |      Put a value into a specified place in a field defined by a data-type.
 |      
 |      Place `val` into `a`'s field defined by `dtype` and beginning `offset`
 |      bytes into the field.
 |      
 |      Parameters
 |      ----------
 |      val : object
 |          Value to be placed in field.
 |      dtype : dtype object
 |          Data-type of the field in which to place `val`.
 |      offset : int, optional
 |          The number of bytes into the field at which to place `val`.
 |      
 |      Returns
 |      -------
 |      None
 |      
 |      See Also
 |      --------
 |      getfield
 |      
 |      Examples
 |      --------
 |      >>> x = np.eye(3)
 |      >>> x.getfield(np.float64)
 |      array([[ 1.,  0.,  0.],
 |             [ 0.,  1.,  0.],
 |             [ 0.,  0.,  1.]])
 |      >>> x.setfield(3, np.int32)
 |      >>> x.getfield(np.int32)
 |      array([[3, 3, 3],
 |             [3, 3, 3],
 |             [3, 3, 3]])
 |      >>> x
 |      array([[  1.00000000e+000,   1.48219694e-323,   1.48219694e-323],
 |             [  1.48219694e-323,   1.00000000e+000,   1.48219694e-323],
 |             [  1.48219694e-323,   1.48219694e-323,   1.00000000e+000]])
 |      >>> x.setfield(np.eye(3), np.int32)
 |      >>> x
 |      array([[ 1.,  0.,  0.],
 |             [ 0.,  1.,  0.],
 |             [ 0.,  0.,  1.]])
 |  
 |  setflags(...)
 |      a.setflags(write=None, align=None, uic=None)
 |      
 |      Set array flags WRITEABLE, ALIGNED, (WRITEBACKIFCOPY and UPDATEIFCOPY),
 |      respectively.
 |      
 |      These Boolean-valued flags affect how numpy interprets the memory
 |      area used by `a` (see Notes below). The ALIGNED flag can only
 |      be set to True if the data is actually aligned according to the type.
 |      The WRITEBACKIFCOPY and (deprecated) UPDATEIFCOPY flags can never be set
 |      to True. The flag WRITEABLE can only be set to True if the array owns its
 |      own memory, or the ultimate owner of the memory exposes a writeable buffer
 |      interface, or is a string. (The exception for string is made so that
 |      unpickling can be done without copying memory.)
 |      
 |      Parameters
 |      ----------
 |      write : bool, optional
 |          Describes whether or not `a` can be written to.
 |      align : bool, optional
 |          Describes whether or not `a` is aligned properly for its type.
 |      uic : bool, optional
 |          Describes whether or not `a` is a copy of another ""base"" array.
 |      
 |      Notes
 |      -----
 |      Array flags provide information about how the memory area used
 |      for the array is to be interpreted. There are 7 Boolean flags
 |      in use, only four of which can be changed by the user:
 |      WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED.
 |      
 |      WRITEABLE (W) the data area can be written to;
 |      
 |      ALIGNED (A) the data and strides are aligned appropriately for the hardware
 |      (as determined by the compiler);
 |      
 |      UPDATEIFCOPY (U) (deprecated), replaced by WRITEBACKIFCOPY;
 |      
 |      WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced
 |      by .base). When the C-API function PyArray_ResolveWritebackIfCopy is
 |      called, the base array will be updated with the contents of this array.
 |      
 |      All flags can be accessed using the single (upper case) letter as well
 |      as the full name.
 |      
 |      Examples
 |      --------
 |      >>> y
 |      array([[3, 1, 7],
 |             [2, 0, 0],
 |             [8, 5, 9]])
 |      >>> y.flags
 |        C_CONTIGUOUS : True
 |        F_CONTIGUOUS : False
 |        OWNDATA : True
 |        WRITEABLE : True
 |        ALIGNED : True
 |        WRITEBACKIFCOPY : False
 |        UPDATEIFCOPY : False
 |      >>> y.setflags(write=0, align=0)
 |      >>> y.flags
 |        C_CONTIGUOUS : True
 |        F_CONTIGUOUS : False
 |        OWNDATA : True
 |        WRITEABLE : False
 |        ALIGNED : False
 |        WRITEBACKIFCOPY : False
 |        UPDATEIFCOPY : False
 |      >>> y.setflags(uic=1)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: cannot set WRITEBACKIFCOPY flag to True
 |  
 |  sort(...)
 |      a.sort(axis=-1, kind='quicksort', order=None)
 |      
 |      Sort an array, in-place.
 |      
 |      Parameters
 |      ----------
 |      axis : int, optional
 |          Axis along which to sort. Default is -1, which means sort along the
 |          last axis.
 |      kind : {'quicksort', 'mergesort', 'heapsort'}, optional
 |          Sorting algorithm. Default is 'quicksort'.
 |      order : str or list of str, optional
 |          When `a` is an array with fields defined, this argument specifies
 |          which fields to compare first, second, etc.  A single field can
 |          be specified as a string, and not all fields need be specified,
 |          but unspecified fields will still be used, in the order in which
 |          they come up in the dtype, to break ties.
 |      
 |      See Also
 |      --------
 |      numpy.sort : Return a sorted copy of an array.
 |      argsort : Indirect sort.
 |      lexsort : Indirect stable sort on multiple keys.
 |      searchsorted : Find elements in sorted array.
 |      partition: Partial sort.
 |      
 |      Notes
 |      -----
 |      See ``sort`` for notes on the different sorting algorithms.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1,4], [3,1]])
 |      >>> a.sort(axis=1)
 |      >>> a
 |      array([[1, 4],
 |             [1, 3]])
 |      >>> a.sort(axis=0)
 |      >>> a
 |      array([[1, 3],
 |             [1, 4]])
 |      
 |      Use the `order` keyword to specify a field to use when sorting a
 |      structured array:
 |      
 |      >>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])
 |      >>> a.sort(order='y')
 |      >>> a
 |      array([('c', 1), ('a', 2)],
 |            dtype=[('x', '|S1'), ('y', '<i4')])
 |  
 |  squeeze(...)
 |      a.squeeze(axis=None)
 |      
 |      Remove single-dimensional entries from the shape of `a`.
 |      
 |      Refer to `numpy.squeeze` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.squeeze : equivalent function
 |  
 |  std(...)
 |      a.std(axis=None, dtype=None, out=None, ddof=0, keepdims=False)
 |      
 |      Returns the standard deviation of the array elements along given axis.
 |      
 |      Refer to `numpy.std` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.std : equivalent function
 |  
 |  sum(...)
 |      a.sum(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Return the sum of the array elements over the given axis.
 |      
 |      Refer to `numpy.sum` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.sum : equivalent function
 |  
 |  swapaxes(...)
 |      a.swapaxes(axis1, axis2)
 |      
 |      Return a view of the array with `axis1` and `axis2` interchanged.
 |      
 |      Refer to `numpy.swapaxes` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.swapaxes : equivalent function
 |  
 |  take(...)
 |      a.take(indices, axis=None, out=None, mode='raise')
 |      
 |      Return an array formed from the elements of `a` at the given indices.
 |      
 |      Refer to `numpy.take` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.take : equivalent function
 |  
 |  tobytes(...)
 |      a.tobytes(order='C')
 |      
 |      Construct Python bytes containing the raw data bytes in the array.
 |      
 |      Constructs Python bytes showing a copy of the raw contents of
 |      data memory. The bytes object can be produced in either 'C' or 'Fortran',
 |      or 'Any' order (the default is 'C'-order). 'Any' order means C-order
 |      unless the F_CONTIGUOUS flag in the array is set, in which case it
 |      means 'Fortran' order.
 |      
 |      .. versionadded:: 1.9.0
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', None}, optional
 |          Order of the data for multidimensional arrays:
 |          C, Fortran, or the same as for the original array.
 |      
 |      Returns
 |      -------
 |      s : bytes
 |          Python bytes exhibiting a copy of `a`'s raw data.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[0, 1], [2, 3]])
 |      >>> x.tobytes()
 |      b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
 |      >>> x.tobytes('C') == x.tobytes()
 |      True
 |      >>> x.tobytes('F')
 |      b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
 |  
 |  tofile(...)
 |      a.tofile(fid, sep="""", format=""%s"")
 |      
 |      Write array to a file as text or binary (default).
 |      
 |      Data is always written in 'C' order, independent of the order of `a`.
 |      The data produced by this method can be recovered using the function
 |      fromfile().
 |      
 |      Parameters
 |      ----------
 |      fid : file or str
 |          An open file object, or a string containing a filename.
 |      sep : str
 |          Separator between array items for text output.
 |          If """" (empty), a binary file is written, equivalent to
 |          ``file.write(a.tobytes())``.
 |      format : str
 |          Format string for text file output.
 |          Each entry in the array is formatted to text by first converting
 |          it to the closest Python type, and then using ""format"" % item.
 |      
 |      Notes
 |      -----
 |      This is a convenience function for quick storage of array data.
 |      Information on endianness and precision is lost, so this method is not a
 |      good choice for files intended to archive data or transport data between
 |      machines with different endianness. Some of these problems can be overcome
 |      by outputting the data as text files, at the expense of speed and file
 |      size.
 |  
 |  tolist(...)
 |      a.tolist()
 |      
 |      Return the array as a (possibly nested) list.
 |      
 |      Return a copy of the array data as a (nested) Python list.
 |      Data items are converted to the nearest compatible Python type.
 |      
 |      Parameters
 |      ----------
 |      none
 |      
 |      Returns
 |      -------
 |      y : list
 |          The possibly nested list of array elements.
 |      
 |      Notes
 |      -----
 |      The array may be recreated, ``a = np.array(a.tolist())``.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([1, 2])
 |      >>> a.tolist()
 |      [1, 2]
 |      >>> a = np.array([[1, 2], [3, 4]])
 |      >>> list(a)
 |      [array([1, 2]), array([3, 4])]
 |      >>> a.tolist()
 |      [[1, 2], [3, 4]]
 |  
 |  tostring(...)
 |      a.tostring(order='C')
 |      
 |      Construct Python bytes containing the raw data bytes in the array.
 |      
 |      Constructs Python bytes showing a copy of the raw contents of
 |      data memory. The bytes object can be produced in either 'C' or 'Fortran',
 |      or 'Any' order (the default is 'C'-order). 'Any' order means C-order
 |      unless the F_CONTIGUOUS flag in the array is set, in which case it
 |      means 'Fortran' order.
 |      
 |      This function is a compatibility alias for tobytes. Despite its name it returns bytes not strings.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', None}, optional
 |          Order of the data for multidimensional arrays:
 |          C, Fortran, or the same as for the original array.
 |      
 |      Returns
 |      -------
 |      s : bytes
 |          Python bytes exhibiting a copy of `a`'s raw data.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[0, 1], [2, 3]])
 |      >>> x.tobytes()
 |      b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
 |      >>> x.tobytes('C') == x.tobytes()
 |      True
 |      >>> x.tobytes('F')
 |      b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
 |  
 |  trace(...)
 |      a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)
 |      
 |      Return the sum along diagonals of the array.
 |      
 |      Refer to `numpy.trace` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.trace : equivalent function
 |  
 |  transpose(...)
 |      a.transpose(*axes)
 |      
 |      Returns a view of the array with axes transposed.
 |      
 |      For a 1-D array, this has no effect. (To change between column and
 |      row vectors, first cast the 1-D array into a matrix object.)
 |      For a 2-D array, this is the usual matrix transpose.
 |      For an n-D array, if axes are given, their order indicates how the
 |      axes are permuted (see Examples). If axes are not provided and
 |      ``a.shape = (i[0], i[1], ... i[n-2], i[n-1])``, then
 |      ``a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0])``.
 |      
 |      Parameters
 |      ----------
 |      axes : None, tuple of ints, or `n` ints
 |      
 |       * None or no argument: reverses the order of the axes.
 |      
 |       * tuple of ints: `i` in the `j`-th place in the tuple means `a`'s
 |         `i`-th axis becomes `a.transpose()`'s `j`-th axis.
 |      
 |       * `n` ints: same as an n-tuple of the same ints (this form is
 |         intended simply as a ""convenience"" alternative to the tuple form)
 |      
 |      Returns
 |      -------
 |      out : ndarray
 |          View of `a`, with axes suitably permuted.
 |      
 |      See Also
 |      --------
 |      ndarray.T : Array property returning the array transposed.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1, 2], [3, 4]])
 |      >>> a
 |      array([[1, 2],
 |             [3, 4]])
 |      >>> a.transpose()
 |      array([[1, 3],
 |             [2, 4]])
 |      >>> a.transpose((1, 0))
 |      array([[1, 3],
 |             [2, 4]])
 |      >>> a.transpose(1, 0)
 |      array([[1, 3],
 |             [2, 4]])
 |  
 |  var(...)
 |      a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False)
 |      
 |      Returns the variance of the array elements, along given axis.
 |      
 |      Refer to `numpy.var` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.var : equivalent function
 |  
 |  view(...)
 |      a.view(dtype=None, type=None)
 |      
 |      New view of array with the same data.
 |      
 |      Parameters
 |      ----------
 |      dtype : data-type or ndarray sub-class, optional
 |          Data-type descriptor of the returned view, e.g., float32 or int16. The
 |          default, None, results in the view having the same data-type as `a`.
 |          This argument can also be specified as an ndarray sub-class, which
 |          then specifies the type of the returned object (this is equivalent to
 |          setting the ``type`` parameter).
 |      type : Python type, optional
 |          Type of the returned view, e.g., ndarray or matrix.  Again, the
 |          default None results in type preservation.
 |      
 |      Notes
 |      -----
 |      ``a.view()`` is used two different ways:
 |      
 |      ``a.view(some_dtype)`` or ``a.view(dtype=some_dtype)`` constructs a view
 |      of the array's memory with a different data-type.  This can cause a
 |      reinterpretation of the bytes of memory.
 |      
 |      ``a.view(ndarray_subclass)`` or ``a.view(type=ndarray_subclass)`` just
 |      returns an instance of `ndarray_subclass` that looks at the same array
 |      (same shape, dtype, etc.)  This does not cause a reinterpretation of the
 |      memory.
 |      
 |      For ``a.view(some_dtype)``, if ``some_dtype`` has a different number of
 |      bytes per entry than the previous dtype (for example, converting a
 |      regular array to a structured array), then the behavior of the view
 |      cannot be predicted just from the superficial appearance of ``a`` (shown
 |      by ``print(a)``). It also depends on exactly how ``a`` is stored in
 |      memory. Therefore if ``a`` is C-ordered versus fortran-ordered, versus
 |      defined as a slice or transpose, etc., the view may give different
 |      results.
 |      
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])
 |      
 |      Viewing array data using a different type and dtype:
 |      
 |      >>> y = x.view(dtype=np.int16, type=np.matrix)
 |      >>> y
 |      matrix([[513]], dtype=int16)
 |      >>> print(type(y))
 |      <class 'numpy.matrixlib.defmatrix.matrix'>
 |      
 |      Creating a view on a structured array so it can be used in calculations
 |      
 |      >>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)])
 |      >>> xv = x.view(dtype=np.int8).reshape(-1,2)
 |      >>> xv
 |      array([[1, 2],
 |             [3, 4]], dtype=int8)
 |      >>> xv.mean(0)
 |      array([ 2.,  3.])
 |      
 |      Making changes to the view changes the underlying array
 |      
 |      >>> xv[0,1] = 20
 |      >>> print(x)
 |      [(1, 20) (3, 4)]
 |      
 |      Using a view to convert an array to a recarray:
 |      
 |      >>> z = x.view(np.recarray)
 |      >>> z.a
 |      array([1], dtype=int8)
 |      
 |      Views share data:
 |      
 |      >>> x[0] = (9, 10)
 |      >>> z[0]
 |      (9, 10)
 |      
 |      Views that change the dtype size (bytes per entry) should normally be
 |      avoided on arrays defined by slices, transposes, fortran-ordering, etc.:
 |      
 |      >>> x = np.array([[1,2,3],[4,5,6]], dtype=np.int16)
 |      >>> y = x[:, 0:2]
 |      >>> y
 |      array([[1, 2],
 |             [4, 5]], dtype=int16)
 |      >>> y.view(dtype=[('width', np.int16), ('length', np.int16)])
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: new type not compatible with array.
 |      >>> z = y.copy()
 |      >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
 |      array([[(1, 2)],
 |             [(4, 5)]], dtype=[('width', '<i2'), ('length', '<i2')])
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from numpy.ndarray:
 |  
 |  T
 |      Same as self.transpose(), except that self is returned if
 |      self.ndim < 2.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[1.,2.],[3.,4.]])
 |      >>> x
 |      array([[ 1.,  2.],
 |             [ 3.,  4.]])
 |      >>> x.T
 |      array([[ 1.,  3.],
 |             [ 2.,  4.]])
 |      >>> x = np.array([1.,2.,3.,4.])
 |      >>> x
 |      array([ 1.,  2.,  3.,  4.])
 |      >>> x.T
 |      array([ 1.,  2.,  3.,  4.])
 |  
 |  __array_finalize__
 |      None.
 |  
 |  __array_interface__
 |      Array protocol: Python side.
 |  
 |  __array_priority__
 |      Array priority.
 |  
 |  __array_struct__
 |      Array protocol: C-struct side.
 |  
 |  base
 |      Base object if memory is from some other object.
 |      
 |      Examples
 |      --------
 |      The base of an array that owns its memory is None:
 |      
 |      >>> x = np.array([1,2,3,4])
 |      >>> x.base is None
 |      True
 |      
 |      Slicing creates a view, whose memory is shared with x:
 |      
 |      >>> y = x[2:]
 |      >>> y.base is x
 |      True
 |  
 |  ctypes
 |      An object to simplify the interaction of the array with the ctypes
 |      module.
 |      
 |      This attribute creates an object that makes it easier to use arrays
 |      when calling shared libraries with the ctypes module. The returned
 |      object has, among others, data, shape, and strides attributes (see
 |      Notes below) which themselves return ctypes objects that can be used
 |      as arguments to a shared library.
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      c : Python object
 |          Possessing attributes data, shape, strides, etc.
 |      
 |      See Also
 |      --------
 |      numpy.ctypeslib
 |      
 |      Notes
 |      -----
 |      Below are the public attributes of this object which were documented
 |      in ""Guide to NumPy"" (we have omitted undocumented public attributes,
 |      as well as documented private attributes):
 |      
 |      * data: A pointer to the memory area of the array as a Python integer.
 |        This memory area may contain data that is not aligned, or not in correct
 |        byte-order. The memory area may not even be writeable. The array
 |        flags and data-type of this array should be respected when passing this
 |        attribute to arbitrary C-code to avoid trouble that can include Python
 |        crashing. User Beware! The value of this attribute is exactly the same
 |        as self._array_interface_['data'][0].
 |      
 |      * shape (c_intp*self.ndim): A ctypes array of length self.ndim where
 |        the basetype is the C-integer corresponding to dtype('p') on this
 |        platform. This base-type could be c_int, c_long, or c_longlong
 |        depending on the platform. The c_intp type is defined accordingly in
 |        numpy.ctypeslib. The ctypes array contains the shape of the underlying
 |        array.
 |      
 |      * strides (c_intp*self.ndim): A ctypes array of length self.ndim where
 |        the basetype is the same as for the shape attribute. This ctypes array
 |        contains the strides information from the underlying array. This strides
 |        information is important for showing how many bytes must be jumped to
 |        get to the next element in the array.
 |      
 |      * data_as(obj): Return the data pointer cast to a particular c-types object.
 |        For example, calling self._as_parameter_ is equivalent to
 |        self.data_as(ctypes.c_void_p). Perhaps you want to use the data as a
 |        pointer to a ctypes array of floating-point data:
 |        self.data_as(ctypes.POINTER(ctypes.c_double)).
 |      
 |      * shape_as(obj): Return the shape tuple as an array of some other c-types
 |        type. For example: self.shape_as(ctypes.c_short).
 |      
 |      * strides_as(obj): Return the strides tuple as an array of some other
 |        c-types type. For example: self.strides_as(ctypes.c_longlong).
 |      
 |      Be careful using the ctypes attribute - especially on temporary
 |      arrays or arrays constructed on the fly. For example, calling
 |      ``(a+b).ctypes.data_as(ctypes.c_void_p)`` returns a pointer to memory
 |      that is invalid because the array created as (a+b) is deallocated
 |      before the next Python statement. You can avoid this problem using
 |      either ``c=a+b`` or ``ct=(a+b).ctypes``. In the latter case, ct will
 |      hold a reference to the array until ct is deleted or re-assigned.
 |      
 |      If the ctypes module is not available, then the ctypes attribute
 |      of array objects still returns something useful, but ctypes objects
 |      are not returned and errors may be raised instead. In particular,
 |      the object will still have the as parameter attribute which will
 |      return an integer equal to the data attribute.
 |      
 |      Examples
 |      --------
 |      >>> import ctypes
 |      >>> x
 |      array([[0, 1],
 |             [2, 3]])
 |      >>> x.ctypes.data
 |      30439712
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long))
 |      <ctypes.LP_c_long object at 0x01F01300>
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)).contents
 |      c_long(0)
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_longlong)).contents
 |      c_longlong(4294967296L)
 |      >>> x.ctypes.shape
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FFD580>
 |      >>> x.ctypes.shape_as(ctypes.c_long)
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
 |      >>> x.ctypes.strides
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
 |      >>> x.ctypes.strides_as(ctypes.c_longlong)
 |      <numpy.core._internal.c_longlong_Array_2 object at 0x01F01300>
 |  
 |  data
 |      Python buffer object pointing to the start of the array's data.
 |  
 |  dtype
 |      Data-type of the array's elements.
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      d : numpy dtype object
 |      
 |      See Also
 |      --------
 |      numpy.dtype
 |      
 |      Examples
 |      --------
 |      >>> x
 |      array([[0, 1],
 |             [2, 3]])
 |      >>> x.dtype
 |      dtype('int32')
 |      >>> type(x.dtype)
 |      <type 'numpy.dtype'>
 |  
 |  flags
 |      Information about the memory layout of the array.
 |      
 |      Attributes
 |      ----------
 |      C_CONTIGUOUS (C)
 |          The data is in a single, C-style contiguous segment.
 |      F_CONTIGUOUS (F)
 |          The data is in a single, Fortran-style contiguous segment.
 |      OWNDATA (O)
 |          The array owns the memory it uses or borrows it from another object.
 |      WRITEABLE (W)
 |          The data area can be written to.  Setting this to False locks
 |          the data, making it read-only.  A view (slice, etc.) inherits WRITEABLE
 |          from its base array at creation time, but a view of a writeable
 |          array may be subsequently locked while the base array remains writeable.
 |          (The opposite is not true, in that a view of a locked array may not
 |          be made writeable.  However, currently, locking a base object does not
 |          lock any views that already reference it, so under that circumstance it
 |          is possible to alter the contents of a locked array via a previously
 |          created writeable view onto it.)  Attempting to change a non-writeable
 |          array raises a RuntimeError exception.
 |      ALIGNED (A)
 |          The data and all elements are aligned appropriately for the hardware.
 |      WRITEBACKIFCOPY (X)
 |          This array is a copy of some other array. The C-API function
 |          PyArray_ResolveWritebackIfCopy must be called before deallocating
 |          to the base array will be updated with the contents of this array.
 |      UPDATEIFCOPY (U)
 |          (Deprecated, use WRITEBACKIFCOPY) This array is a copy of some other array.
 |          When this array is
 |          deallocated, the base array will be updated with the contents of
 |          this array.
 |      FNC
 |          F_CONTIGUOUS and not C_CONTIGUOUS.
 |      FORC
 |          F_CONTIGUOUS or C_CONTIGUOUS (one-segment test).
 |      BEHAVED (B)
 |          ALIGNED and WRITEABLE.
 |      CARRAY (CA)
 |          BEHAVED and C_CONTIGUOUS.
 |      FARRAY (FA)
 |          BEHAVED and F_CONTIGUOUS and not C_CONTIGUOUS.
 |      
 |      Notes
 |      -----
 |      The `flags` object can be accessed dictionary-like (as in ``a.flags['WRITEABLE']``),
 |      or by using lowercased attribute names (as in ``a.flags.writeable``). Short flag
 |      names are only supported in dictionary access.
 |      
 |      Only the WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED flags can be
 |      changed by the user, via direct assignment to the attribute or dictionary
 |      entry, or by calling `ndarray.setflags`.
 |      
 |      The array flags cannot be set arbitrarily:
 |      
 |      - UPDATEIFCOPY can only be set ``False``.
 |      - WRITEBACKIFCOPY can only be set ``False``.
 |      - ALIGNED can only be set ``True`` if the data is truly aligned.
 |      - WRITEABLE can only be set ``True`` if the array owns its own memory
 |        or the ultimate owner of the memory exposes a writeable buffer
 |        interface or is a string.
 |      
 |      Arrays can be both C-style and Fortran-style contiguous simultaneously.
 |      This is clear for 1-dimensional arrays, but can also be true for higher
 |      dimensional arrays.
 |      
 |      Even for contiguous arrays a stride for a given dimension
 |      ``arr.strides[dim]`` may be *arbitrary* if ``arr.shape[dim] == 1``
 |      or the array has no elements.
 |      It does *not* generally hold that ``self.strides[-1] == self.itemsize``
 |      for C-style contiguous arrays or ``self.strides[0] == self.itemsize`` for
 |      Fortran-style contiguous arrays is true.
 |  
 |  flat
 |      A 1-D iterator over the array.
 |      
 |      This is a `numpy.flatiter` instance, which acts similarly to, but is not
 |      a subclass of, Python's built-in iterator object.
 |      
 |      See Also
 |      --------
 |      flatten : Return a copy of the array collapsed into one dimension.
 |      
 |      flatiter
 |      
 |      Examples
 |      --------
 |      >>> x = np.arange(1, 7).reshape(2, 3)
 |      >>> x
 |      array([[1, 2, 3],
 |             [4, 5, 6]])
 |      >>> x.flat[3]
 |      4
 |      >>> x.T
 |      array([[1, 4],
 |             [2, 5],
 |             [3, 6]])
 |      >>> x.T.flat[3]
 |      5
 |      >>> type(x.flat)
 |      <type 'numpy.flatiter'>
 |      
 |      An assignment example:
 |      
 |      >>> x.flat = 3; x
 |      array([[3, 3, 3],
 |             [3, 3, 3]])
 |      >>> x.flat[[1,4]] = 1; x
 |      array([[3, 1, 3],
 |             [3, 1, 3]])
 |  
 |  imag
 |      The imaginary part of the array.
 |      
 |      Examples
 |      --------
 |      >>> x = np.sqrt([1+0j, 0+1j])
 |      >>> x.imag
 |      array([ 0.        ,  0.70710678])
 |      >>> x.imag.dtype
 |      dtype('float64')
 |  
 |  itemsize
 |      Length of one array element in bytes.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1,2,3], dtype=np.float64)
 |      >>> x.itemsize
 |      8
 |      >>> x = np.array([1,2,3], dtype=np.complex128)
 |      >>> x.itemsize
 |      16
 |  
 |  nbytes
 |      Total bytes consumed by the elements of the array.
 |      
 |      Notes
 |      -----
 |      Does not include memory consumed by non-element attributes of the
 |      array object.
 |      
 |      Examples
 |      --------
 |      >>> x = np.zeros((3,5,2), dtype=np.complex128)
 |      >>> x.nbytes
 |      480
 |      >>> np.prod(x.shape) * x.itemsize
 |      480
 |  
 |  ndim
 |      Number of array dimensions.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 3])
 |      >>> x.ndim
 |      1
 |      >>> y = np.zeros((2, 3, 4))
 |      >>> y.ndim
 |      3
 |  
 |  real
 |      The real part of the array.
 |      
 |      Examples
 |      --------
 |      >>> x = np.sqrt([1+0j, 0+1j])
 |      >>> x.real
 |      array([ 1.        ,  0.70710678])
 |      >>> x.real.dtype
 |      dtype('float64')
 |      
 |      See Also
 |      --------
 |      numpy.real : equivalent function
 |  
 |  shape
 |      Tuple of array dimensions.
 |      
 |      The shape property is usually used to get the current shape of an array,
 |      but may also be used to reshape the array in-place by assigning a tuple of
 |      array dimensions to it.  As with `numpy.reshape`, one of the new shape
 |      dimensions can be -1, in which case its value is inferred from the size of
 |      the array and the remaining dimensions. Reshaping an array in-place will
 |      fail if a copy is required.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 3, 4])
 |      >>> x.shape
 |      (4,)
 |      >>> y = np.zeros((2, 3, 4))
 |      >>> y.shape
 |      (2, 3, 4)
 |      >>> y.shape = (3, 8)
 |      >>> y
 |      array([[ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
 |             [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
 |             [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.]])
 |      >>> y.shape = (3, 6)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: total size of new array must be unchanged
 |      >>> np.zeros((4,2))[::2].shape = (-1,)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      AttributeError: incompatible shape for a non-contiguous array
 |      
 |      See Also
 |      --------
 |      numpy.reshape : similar function
 |      ndarray.reshape : similar method
 |  
 |  size
 |      Number of elements in the array.
 |      
 |      Equivalent to ``np.prod(a.shape)``, i.e., the product of the array's
 |      dimensions.
 |      
 |      Examples
 |      --------
 |      >>> x = np.zeros((3, 5, 2), dtype=np.complex128)
 |      >>> x.size
 |      30
 |      >>> np.prod(x.shape)
 |      30
 |  
 |  strides
 |      Tuple of bytes to step in each dimension when traversing an array.
 |      
 |      The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a`
 |      is::
 |      
 |          offset = sum(np.array(i) * a.strides)
 |      
 |      A more detailed explanation of strides can be found in the
 |      ""ndarray.rst"" file in the NumPy reference guide.
 |      
 |      Notes
 |      -----
 |      Imagine an array of 32-bit integers (each 4 bytes)::
 |      
 |        x = np.array([[0, 1, 2, 3, 4],
 |                      [5, 6, 7, 8, 9]], dtype=np.int32)
 |      
 |      This array is stored in memory as 40 bytes, one after the other
 |      (known as a contiguous block of memory).  The strides of an array tell
 |      us how many bytes we have to skip in memory to move to the next position
 |      along a certain axis.  For example, we have to skip 4 bytes (1 value) to
 |      move to the next column, but 20 bytes (5 values) to get to the same
 |      position in the next row.  As such, the strides for the array `x` will be
 |      ``(20, 4)``.
 |      
 |      See Also
 |      --------
 |      numpy.lib.stride_tricks.as_strided
 |      
 |      Examples
 |      --------
 |      >>> y = np.reshape(np.arange(2*3*4), (2,3,4))
 |      >>> y
 |      array([[[ 0,  1,  2,  3],
 |              [ 4,  5,  6,  7],
 |              [ 8,  9, 10, 11]],
 |             [[12, 13, 14, 15],
 |              [16, 17, 18, 19],
 |              [20, 21, 22, 23]]])
 |      >>> y.strides
 |      (48, 16, 4)
 |      >>> y[1,1,1]
 |      17
 |      >>> offset=sum(y.strides * np.array((1,1,1)))
 |      >>> offset/y.itemsize
 |      17
 |      
 |      >>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0)
 |      >>> x.strides
 |      (32, 4, 224, 1344)
 |      >>> i = np.array([3,5,2,2])
 |      >>> offset = sum(i * x.strides)
 |      >>> x[3,5,2,2]
 |      813
 |      >>> offset / x.itemsize
 |      813
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from numpy.ndarray:
 |  
 |  __hash__ = None
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.matlab.mio5_params.MatlabFunction,io.matlab.mio5_params,MatlabFunction,"Python Library Documentation: class MatlabFunction in module scipy.io.matlab.mio5_params

class MatlabFunction(numpy.ndarray)
 |  Subclass to signal this is a matlab function
 |  
 |  Method resolution order:
 |      MatlabFunction
 |      numpy.ndarray
 |      builtins.object
 |  
 |  Static methods defined here:
 |  
 |  __new__(cls, input_array)
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from numpy.ndarray:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __array__(...)
 |      a.__array__(|dtype) -> reference if type unchanged, copy otherwise.
 |      
 |      Returns either a new reference to self if dtype is not given or a new array
 |      of provided data type if dtype is different from the current dtype of the
 |      array.
 |  
 |  __array_prepare__(...)
 |      a.__array_prepare__(obj) -> Object of same type as ndarray object obj.
 |  
 |  __array_ufunc__(...)
 |  
 |  __array_wrap__(...)
 |      a.__array_wrap__(obj) -> Object of same type as ndarray object a.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __complex__(...)
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __copy__(...)
 |      a.__copy__()
 |      
 |      Used if :func:`copy.copy` is called on an array. Returns a copy of the array.
 |      
 |      Equivalent to ``a.copy(order='K')``.
 |  
 |  __deepcopy__(...)
 |      a.__deepcopy__(memo, /) -> Deep copy of array.
 |      
 |      Used if :func:`copy.deepcopy` is called on an array.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __format__(...)
 |      default object formatter
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iadd__(self, value, /)
 |      Return self+=value.
 |  
 |  __iand__(self, value, /)
 |      Return self&=value.
 |  
 |  __ifloordiv__(self, value, /)
 |      Return self//=value.
 |  
 |  __ilshift__(self, value, /)
 |      Return self<<=value.
 |  
 |  __imatmul__(self, value, /)
 |      Return self@=value.
 |  
 |  __imod__(self, value, /)
 |      Return self%=value.
 |  
 |  __imul__(self, value, /)
 |      Return self*=value.
 |  
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __ior__(self, value, /)
 |      Return self|=value.
 |  
 |  __ipow__(self, value, /)
 |      Return self**=value.
 |  
 |  __irshift__(self, value, /)
 |      Return self>>=value.
 |  
 |  __isub__(self, value, /)
 |      Return self-=value.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __itruediv__(self, value, /)
 |      Return self/=value.
 |  
 |  __ixor__(self, value, /)
 |      Return self^=value.
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __matmul__(self, value, /)
 |      Return self@value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __reduce__(...)
 |      a.__reduce__()
 |      
 |      For pickling.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmatmul__(self, value, /)
 |      Return value@self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __setstate__(...)
 |      a.__setstate__(state, /)
 |      
 |      For unpickling.
 |      
 |      The `state` argument must be a sequence that contains the following
 |      elements:
 |      
 |      Parameters
 |      ----------
 |      version : int
 |          optional pickle version. If omitted defaults to 0.
 |      shape : tuple
 |      dtype : data-type
 |      isFortran : bool
 |      rawdata : string or list
 |          a binary string with the data (or a list if 'a' is an object array)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  all(...)
 |      a.all(axis=None, out=None, keepdims=False)
 |      
 |      Returns True if all elements evaluate to True.
 |      
 |      Refer to `numpy.all` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.all : equivalent function
 |  
 |  any(...)
 |      a.any(axis=None, out=None, keepdims=False)
 |      
 |      Returns True if any of the elements of `a` evaluate to True.
 |      
 |      Refer to `numpy.any` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.any : equivalent function
 |  
 |  argmax(...)
 |      a.argmax(axis=None, out=None)
 |      
 |      Return indices of the maximum values along the given axis.
 |      
 |      Refer to `numpy.argmax` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argmax : equivalent function
 |  
 |  argmin(...)
 |      a.argmin(axis=None, out=None)
 |      
 |      Return indices of the minimum values along the given axis of `a`.
 |      
 |      Refer to `numpy.argmin` for detailed documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argmin : equivalent function
 |  
 |  argpartition(...)
 |      a.argpartition(kth, axis=-1, kind='introselect', order=None)
 |      
 |      Returns the indices that would partition this array.
 |      
 |      Refer to `numpy.argpartition` for full documentation.
 |      
 |      .. versionadded:: 1.8.0
 |      
 |      See Also
 |      --------
 |      numpy.argpartition : equivalent function
 |  
 |  argsort(...)
 |      a.argsort(axis=-1, kind='quicksort', order=None)
 |      
 |      Returns the indices that would sort this array.
 |      
 |      Refer to `numpy.argsort` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argsort : equivalent function
 |  
 |  astype(...)
 |      a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)
 |      
 |      Copy of the array, cast to a specified type.
 |      
 |      Parameters
 |      ----------
 |      dtype : str or dtype
 |          Typecode or data-type to which the array is cast.
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          Controls the memory layout order of the result.
 |          'C' means C order, 'F' means Fortran order, 'A'
 |          means 'F' order if all the arrays are Fortran contiguous,
 |          'C' order otherwise, and 'K' means as close to the
 |          order the array elements appear in memory as possible.
 |          Default is 'K'.
 |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
 |          Controls what kind of data casting may occur. Defaults to 'unsafe'
 |          for backwards compatibility.
 |      
 |            * 'no' means the data types should not be cast at all.
 |            * 'equiv' means only byte-order changes are allowed.
 |            * 'safe' means only casts which can preserve values are allowed.
 |            * 'same_kind' means only safe casts or casts within a kind,
 |              like float64 to float32, are allowed.
 |            * 'unsafe' means any data conversions may be done.
 |      subok : bool, optional
 |          If True, then sub-classes will be passed-through (default), otherwise
 |          the returned array will be forced to be a base-class array.
 |      copy : bool, optional
 |          By default, astype always returns a newly allocated array. If this
 |          is set to false, and the `dtype`, `order`, and `subok`
 |          requirements are satisfied, the input array is returned instead
 |          of a copy.
 |      
 |      Returns
 |      -------
 |      arr_t : ndarray
 |          Unless `copy` is False and the other conditions for returning the input
 |          array are satisfied (see description for `copy` input parameter), `arr_t`
 |          is a new array of the same shape as the input array, with dtype, order
 |          given by `dtype`, `order`.
 |      
 |      Notes
 |      -----
 |      Starting in NumPy 1.9, astype method now returns an error if the string
 |      dtype to cast to is not long enough in 'safe' casting mode to hold the max
 |      value of integer/float array that is being casted. Previously the casting
 |      was allowed even if the result was truncated.
 |      
 |      Raises
 |      ------
 |      ComplexWarning
 |          When casting from complex to float or int. To avoid this,
 |          one should use ``a.real.astype(t)``.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 2.5])
 |      >>> x
 |      array([ 1. ,  2. ,  2.5])
 |      
 |      >>> x.astype(int)
 |      array([1, 2, 2])
 |  
 |  byteswap(...)
 |      a.byteswap(inplace=False)
 |      
 |      Swap the bytes of the array elements
 |      
 |      Toggle between low-endian and big-endian data representation by
 |      returning a byteswapped array, optionally swapped in-place.
 |      
 |      Parameters
 |      ----------
 |      inplace : bool, optional
 |          If ``True``, swap bytes in-place, default is ``False``.
 |      
 |      Returns
 |      -------
 |      out : ndarray
 |          The byteswapped array. If `inplace` is ``True``, this is
 |          a view to self.
 |      
 |      Examples
 |      --------
 |      >>> A = np.array([1, 256, 8755], dtype=np.int16)
 |      >>> map(hex, A)
 |      ['0x1', '0x100', '0x2233']
 |      >>> A.byteswap(inplace=True)
 |      array([  256,     1, 13090], dtype=int16)
 |      >>> map(hex, A)
 |      ['0x100', '0x1', '0x3322']
 |      
 |      Arrays of strings are not swapped
 |      
 |      >>> A = np.array(['ceg', 'fac'])
 |      >>> A.byteswap()
 |      array(['ceg', 'fac'],
 |            dtype='|S3')
 |  
 |  choose(...)
 |      a.choose(choices, out=None, mode='raise')
 |      
 |      Use an index array to construct a new array from a set of choices.
 |      
 |      Refer to `numpy.choose` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.choose : equivalent function
 |  
 |  clip(...)
 |      a.clip(min=None, max=None, out=None)
 |      
 |      Return an array whose values are limited to ``[min, max]``.
 |      One of max or min must be given.
 |      
 |      Refer to `numpy.clip` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.clip : equivalent function
 |  
 |  compress(...)
 |      a.compress(condition, axis=None, out=None)
 |      
 |      Return selected slices of this array along given axis.
 |      
 |      Refer to `numpy.compress` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.compress : equivalent function
 |  
 |  conj(...)
 |      a.conj()
 |      
 |      Complex-conjugate all elements.
 |      
 |      Refer to `numpy.conjugate` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.conjugate : equivalent function
 |  
 |  conjugate(...)
 |      a.conjugate()
 |      
 |      Return the complex conjugate, element-wise.
 |      
 |      Refer to `numpy.conjugate` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.conjugate : equivalent function
 |  
 |  copy(...)
 |      a.copy(order='C')
 |      
 |      Return a copy of the array.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          Controls the memory layout of the copy. 'C' means C-order,
 |          'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
 |          'C' otherwise. 'K' means match the layout of `a` as closely
 |          as possible. (Note that this function and :func:`numpy.copy` are very
 |          similar, but have different default values for their order=
 |          arguments.)
 |      
 |      See also
 |      --------
 |      numpy.copy
 |      numpy.copyto
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[1,2,3],[4,5,6]], order='F')
 |      
 |      >>> y = x.copy()
 |      
 |      >>> x.fill(0)
 |      
 |      >>> x
 |      array([[0, 0, 0],
 |             [0, 0, 0]])
 |      
 |      >>> y
 |      array([[1, 2, 3],
 |             [4, 5, 6]])
 |      
 |      >>> y.flags['C_CONTIGUOUS']
 |      True
 |  
 |  cumprod(...)
 |      a.cumprod(axis=None, dtype=None, out=None)
 |      
 |      Return the cumulative product of the elements along the given axis.
 |      
 |      Refer to `numpy.cumprod` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.cumprod : equivalent function
 |  
 |  cumsum(...)
 |      a.cumsum(axis=None, dtype=None, out=None)
 |      
 |      Return the cumulative sum of the elements along the given axis.
 |      
 |      Refer to `numpy.cumsum` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.cumsum : equivalent function
 |  
 |  diagonal(...)
 |      a.diagonal(offset=0, axis1=0, axis2=1)
 |      
 |      Return specified diagonals. In NumPy 1.9 the returned array is a
 |      read-only view instead of a copy as in previous NumPy versions.  In
 |      a future version the read-only restriction will be removed.
 |      
 |      Refer to :func:`numpy.diagonal` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.diagonal : equivalent function
 |  
 |  dot(...)
 |      a.dot(b, out=None)
 |      
 |      Dot product of two arrays.
 |      
 |      Refer to `numpy.dot` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.dot : equivalent function
 |      
 |      Examples
 |      --------
 |      >>> a = np.eye(2)
 |      >>> b = np.ones((2, 2)) * 2
 |      >>> a.dot(b)
 |      array([[ 2.,  2.],
 |             [ 2.,  2.]])
 |      
 |      This array method can be conveniently chained:
 |      
 |      >>> a.dot(b).dot(b)
 |      array([[ 8.,  8.],
 |             [ 8.,  8.]])
 |  
 |  dump(...)
 |      a.dump(file)
 |      
 |      Dump a pickle of the array to the specified file.
 |      The array can be read back with pickle.load or numpy.load.
 |      
 |      Parameters
 |      ----------
 |      file : str
 |          A string naming the dump file.
 |  
 |  dumps(...)
 |      a.dumps()
 |      
 |      Returns the pickle of the array as a string.
 |      pickle.loads or numpy.loads will convert the string back to an array.
 |      
 |      Parameters
 |      ----------
 |      None
 |  
 |  fill(...)
 |      a.fill(value)
 |      
 |      Fill the array with a scalar value.
 |      
 |      Parameters
 |      ----------
 |      value : scalar
 |          All elements of `a` will be assigned this value.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([1, 2])
 |      >>> a.fill(0)
 |      >>> a
 |      array([0, 0])
 |      >>> a = np.empty(2)
 |      >>> a.fill(1)
 |      >>> a
 |      array([ 1.,  1.])
 |  
 |  flatten(...)
 |      a.flatten(order='C')
 |      
 |      Return a copy of the array collapsed into one dimension.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          'C' means to flatten in row-major (C-style) order.
 |          'F' means to flatten in column-major (Fortran-
 |          style) order. 'A' means to flatten in column-major
 |          order if `a` is Fortran *contiguous* in memory,
 |          row-major order otherwise. 'K' means to flatten
 |          `a` in the order the elements occur in memory.
 |          The default is 'C'.
 |      
 |      Returns
 |      -------
 |      y : ndarray
 |          A copy of the input array, flattened to one dimension.
 |      
 |      See Also
 |      --------
 |      ravel : Return a flattened array.
 |      flat : A 1-D flat iterator over the array.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1,2], [3,4]])
 |      >>> a.flatten()
 |      array([1, 2, 3, 4])
 |      >>> a.flatten('F')
 |      array([1, 3, 2, 4])
 |  
 |  getfield(...)
 |      a.getfield(dtype, offset=0)
 |      
 |      Returns a field of the given array as a certain type.
 |      
 |      A field is a view of the array data with a given data-type. The values in
 |      the view are determined by the given type and the offset into the current
 |      array in bytes. The offset needs to be such that the view dtype fits in the
 |      array dtype; for example an array of dtype complex128 has 16-byte elements.
 |      If taking a view with a 32-bit integer (4 bytes), the offset needs to be
 |      between 0 and 12 bytes.
 |      
 |      Parameters
 |      ----------
 |      dtype : str or dtype
 |          The data type of the view. The dtype size of the view can not be larger
 |          than that of the array itself.
 |      offset : int
 |          Number of bytes to skip before beginning the element view.
 |      
 |      Examples
 |      --------
 |      >>> x = np.diag([1.+1.j]*2)
 |      >>> x[1, 1] = 2 + 4.j
 |      >>> x
 |      array([[ 1.+1.j,  0.+0.j],
 |             [ 0.+0.j,  2.+4.j]])
 |      >>> x.getfield(np.float64)
 |      array([[ 1.,  0.],
 |             [ 0.,  2.]])
 |      
 |      By choosing an offset of 8 bytes we can select the complex part of the
 |      array for our view:
 |      
 |      >>> x.getfield(np.float64, offset=8)
 |      array([[ 1.,  0.],
 |         [ 0.,  4.]])
 |  
 |  item(...)
 |      a.item(*args)
 |      
 |      Copy an element of an array to a standard Python scalar and return it.
 |      
 |      Parameters
 |      ----------
 |      \*args : Arguments (variable number and type)
 |      
 |          * none: in this case, the method only works for arrays
 |            with one element (`a.size == 1`), which element is
 |            copied into a standard Python scalar object and returned.
 |      
 |          * int_type: this argument is interpreted as a flat index into
 |            the array, specifying which element to copy and return.
 |      
 |          * tuple of int_types: functions as does a single int_type argument,
 |            except that the argument is interpreted as an nd-index into the
 |            array.
 |      
 |      Returns
 |      -------
 |      z : Standard Python scalar object
 |          A copy of the specified element of the array as a suitable
 |          Python scalar
 |      
 |      Notes
 |      -----
 |      When the data type of `a` is longdouble or clongdouble, item() returns
 |      a scalar array object because there is no available Python scalar that
 |      would not lose information. Void arrays return a buffer object for item(),
 |      unless fields are defined, in which case a tuple is returned.
 |      
 |      `item` is very similar to a[args], except, instead of an array scalar,
 |      a standard Python scalar is returned. This can be useful for speeding up
 |      access to elements of the array and doing arithmetic on elements of the
 |      array using Python's optimized math.
 |      
 |      Examples
 |      --------
 |      >>> x = np.random.randint(9, size=(3, 3))
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 8, 3],
 |             [8, 5, 3]])
 |      >>> x.item(3)
 |      2
 |      >>> x.item(7)
 |      5
 |      >>> x.item((0, 1))
 |      1
 |      >>> x.item((2, 2))
 |      3
 |  
 |  itemset(...)
 |      a.itemset(*args)
 |      
 |      Insert scalar into an array (scalar is cast to array's dtype, if possible)
 |      
 |      There must be at least 1 argument, and define the last argument
 |      as *item*.  Then, ``a.itemset(*args)`` is equivalent to but faster
 |      than ``a[args] = item``.  The item should be a scalar value and `args`
 |      must select a single item in the array `a`.
 |      
 |      Parameters
 |      ----------
 |      \*args : Arguments
 |          If one argument: a scalar, only used in case `a` is of size 1.
 |          If two arguments: the last argument is the value to be set
 |          and must be a scalar, the first argument specifies a single array
 |          element location. It is either an int or a tuple.
 |      
 |      Notes
 |      -----
 |      Compared to indexing syntax, `itemset` provides some speed increase
 |      for placing a scalar into a particular location in an `ndarray`,
 |      if you must do this.  However, generally this is discouraged:
 |      among other problems, it complicates the appearance of the code.
 |      Also, when using `itemset` (and `item`) inside a loop, be sure
 |      to assign the methods to a local variable to avoid the attribute
 |      look-up at each loop iteration.
 |      
 |      Examples
 |      --------
 |      >>> x = np.random.randint(9, size=(3, 3))
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 8, 3],
 |             [8, 5, 3]])
 |      >>> x.itemset(4, 0)
 |      >>> x.itemset((2, 2), 9)
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 0, 3],
 |             [8, 5, 9]])
 |  
 |  max(...)
 |      a.max(axis=None, out=None, keepdims=False)
 |      
 |      Return the maximum along a given axis.
 |      
 |      Refer to `numpy.amax` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.amax : equivalent function
 |  
 |  mean(...)
 |      a.mean(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Returns the average of the array elements along given axis.
 |      
 |      Refer to `numpy.mean` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.mean : equivalent function
 |  
 |  min(...)
 |      a.min(axis=None, out=None, keepdims=False)
 |      
 |      Return the minimum along a given axis.
 |      
 |      Refer to `numpy.amin` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.amin : equivalent function
 |  
 |  newbyteorder(...)
 |      arr.newbyteorder(new_order='S')
 |      
 |      Return the array with the same data viewed with a different byte order.
 |      
 |      Equivalent to::
 |      
 |          arr.view(arr.dtype.newbytorder(new_order))
 |      
 |      Changes are also made in all fields and sub-arrays of the array data
 |      type.
 |      
 |      
 |      
 |      Parameters
 |      ----------
 |      new_order : string, optional
 |          Byte order to force; a value from the byte order specifications
 |          below. `new_order` codes can be any of:
 |      
 |          * 'S' - swap dtype from current to opposite endian
 |          * {'<', 'L'} - little endian
 |          * {'>', 'B'} - big endian
 |          * {'=', 'N'} - native order
 |          * {'|', 'I'} - ignore (no change to byte order)
 |      
 |          The default value ('S') results in swapping the current
 |          byte order. The code does a case-insensitive check on the first
 |          letter of `new_order` for the alternatives above.  For example,
 |          any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 |      
 |      
 |      Returns
 |      -------
 |      new_arr : array
 |          New array object with the dtype reflecting given change to the
 |          byte order.
 |  
 |  nonzero(...)
 |      a.nonzero()
 |      
 |      Return the indices of the elements that are non-zero.
 |      
 |      Refer to `numpy.nonzero` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.nonzero : equivalent function
 |  
 |  partition(...)
 |      a.partition(kth, axis=-1, kind='introselect', order=None)
 |      
 |      Rearranges the elements in the array in such a way that value of the
 |      element in kth position is in the position it would be in a sorted array.
 |      All elements smaller than the kth element are moved before this element and
 |      all equal or greater are moved behind it. The ordering of the elements in
 |      the two partitions is undefined.
 |      
 |      .. versionadded:: 1.8.0
 |      
 |      Parameters
 |      ----------
 |      kth : int or sequence of ints
 |          Element index to partition by. The kth element value will be in its
 |          final sorted position and all smaller elements will be moved before it
 |          and all equal or greater elements behind it.
 |          The order all elements in the partitions is undefined.
 |          If provided with a sequence of kth it will partition all elements
 |          indexed by kth of them into their sorted position at once.
 |      axis : int, optional
 |          Axis along which to sort. Default is -1, which means sort along the
 |          last axis.
 |      kind : {'introselect'}, optional
 |          Selection algorithm. Default is 'introselect'.
 |      order : str or list of str, optional
 |          When `a` is an array with fields defined, this argument specifies
 |          which fields to compare first, second, etc.  A single field can
 |          be specified as a string, and not all fields need be specified,
 |          but unspecified fields will still be used, in the order in which
 |          they come up in the dtype, to break ties.
 |      
 |      See Also
 |      --------
 |      numpy.partition : Return a parititioned copy of an array.
 |      argpartition : Indirect partition.
 |      sort : Full sort.
 |      
 |      Notes
 |      -----
 |      See ``np.partition`` for notes on the different algorithms.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([3, 4, 2, 1])
 |      >>> a.partition(3)
 |      >>> a
 |      array([2, 1, 3, 4])
 |      
 |      >>> a.partition((1, 3))
 |      array([1, 2, 3, 4])
 |  
 |  prod(...)
 |      a.prod(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Return the product of the array elements over the given axis
 |      
 |      Refer to `numpy.prod` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.prod : equivalent function
 |  
 |  ptp(...)
 |      a.ptp(axis=None, out=None)
 |      
 |      Peak to peak (maximum - minimum) value along a given axis.
 |      
 |      Refer to `numpy.ptp` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.ptp : equivalent function
 |  
 |  put(...)
 |      a.put(indices, values, mode='raise')
 |      
 |      Set ``a.flat[n] = values[n]`` for all `n` in indices.
 |      
 |      Refer to `numpy.put` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.put : equivalent function
 |  
 |  ravel(...)
 |      a.ravel([order])
 |      
 |      Return a flattened array.
 |      
 |      Refer to `numpy.ravel` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.ravel : equivalent function
 |      
 |      ndarray.flat : a flat iterator on the array.
 |  
 |  repeat(...)
 |      a.repeat(repeats, axis=None)
 |      
 |      Repeat elements of an array.
 |      
 |      Refer to `numpy.repeat` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.repeat : equivalent function
 |  
 |  reshape(...)
 |      a.reshape(shape, order='C')
 |      
 |      Returns an array containing the same data with a new shape.
 |      
 |      Refer to `numpy.reshape` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.reshape : equivalent function
 |      
 |      Notes
 |      -----
 |      Unlike the free function `numpy.reshape`, this method on `ndarray` allows
 |      the elements of the shape parameter to be passed in as separate arguments.
 |      For example, ``a.reshape(10, 11)`` is equivalent to
 |      ``a.reshape((10, 11))``.
 |  
 |  resize(...)
 |      a.resize(new_shape, refcheck=True)
 |      
 |      Change shape and size of array in-place.
 |      
 |      Parameters
 |      ----------
 |      new_shape : tuple of ints, or `n` ints
 |          Shape of resized array.
 |      refcheck : bool, optional
 |          If False, reference count will not be checked. Default is True.
 |      
 |      Returns
 |      -------
 |      None
 |      
 |      Raises
 |      ------
 |      ValueError
 |          If `a` does not own its own data or references or views to it exist,
 |          and the data memory must be changed.
 |          PyPy only: will always raise if the data memory must be changed, since
 |          there is no reliable way to determine if references or views to it
 |          exist.
 |      
 |      SystemError
 |          If the `order` keyword argument is specified. This behaviour is a
 |          bug in NumPy.
 |      
 |      See Also
 |      --------
 |      resize : Return a new array with the specified shape.
 |      
 |      Notes
 |      -----
 |      This reallocates space for the data area if necessary.
 |      
 |      Only contiguous arrays (data elements consecutive in memory) can be
 |      resized.
 |      
 |      The purpose of the reference count check is to make sure you
 |      do not use this array as a buffer for another Python object and then
 |      reallocate the memory. However, reference counts can increase in
 |      other ways so if you are sure that you have not shared the memory
 |      for this array with another Python object, then you may safely set
 |      `refcheck` to False.
 |      
 |      Examples
 |      --------
 |      Shrinking an array: array is flattened (in the order that the data are
 |      stored in memory), resized, and reshaped:
 |      
 |      >>> a = np.array([[0, 1], [2, 3]], order='C')
 |      >>> a.resize((2, 1))
 |      >>> a
 |      array([[0],
 |             [1]])
 |      
 |      >>> a = np.array([[0, 1], [2, 3]], order='F')
 |      >>> a.resize((2, 1))
 |      >>> a
 |      array([[0],
 |             [2]])
 |      
 |      Enlarging an array: as above, but missing entries are filled with zeros:
 |      
 |      >>> b = np.array([[0, 1], [2, 3]])
 |      >>> b.resize(2, 3) # new_shape parameter doesn't have to be a tuple
 |      >>> b
 |      array([[0, 1, 2],
 |             [3, 0, 0]])
 |      
 |      Referencing an array prevents resizing...
 |      
 |      >>> c = a
 |      >>> a.resize((1, 1))
 |      Traceback (most recent call last):
 |      ...
 |      ValueError: cannot resize an array that has been referenced ...
 |      
 |      Unless `refcheck` is False:
 |      
 |      >>> a.resize((1, 1), refcheck=False)
 |      >>> a
 |      array([[0]])
 |      >>> c
 |      array([[0]])
 |  
 |  round(...)
 |      a.round(decimals=0, out=None)
 |      
 |      Return `a` with each element rounded to the given number of decimals.
 |      
 |      Refer to `numpy.around` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.around : equivalent function
 |  
 |  searchsorted(...)
 |      a.searchsorted(v, side='left', sorter=None)
 |      
 |      Find indices where elements of v should be inserted in a to maintain order.
 |      
 |      For full documentation, see `numpy.searchsorted`
 |      
 |      See Also
 |      --------
 |      numpy.searchsorted : equivalent function
 |  
 |  setfield(...)
 |      a.setfield(val, dtype, offset=0)
 |      
 |      Put a value into a specified place in a field defined by a data-type.
 |      
 |      Place `val` into `a`'s field defined by `dtype` and beginning `offset`
 |      bytes into the field.
 |      
 |      Parameters
 |      ----------
 |      val : object
 |          Value to be placed in field.
 |      dtype : dtype object
 |          Data-type of the field in which to place `val`.
 |      offset : int, optional
 |          The number of bytes into the field at which to place `val`.
 |      
 |      Returns
 |      -------
 |      None
 |      
 |      See Also
 |      --------
 |      getfield
 |      
 |      Examples
 |      --------
 |      >>> x = np.eye(3)
 |      >>> x.getfield(np.float64)
 |      array([[ 1.,  0.,  0.],
 |             [ 0.,  1.,  0.],
 |             [ 0.,  0.,  1.]])
 |      >>> x.setfield(3, np.int32)
 |      >>> x.getfield(np.int32)
 |      array([[3, 3, 3],
 |             [3, 3, 3],
 |             [3, 3, 3]])
 |      >>> x
 |      array([[  1.00000000e+000,   1.48219694e-323,   1.48219694e-323],
 |             [  1.48219694e-323,   1.00000000e+000,   1.48219694e-323],
 |             [  1.48219694e-323,   1.48219694e-323,   1.00000000e+000]])
 |      >>> x.setfield(np.eye(3), np.int32)
 |      >>> x
 |      array([[ 1.,  0.,  0.],
 |             [ 0.,  1.,  0.],
 |             [ 0.,  0.,  1.]])
 |  
 |  setflags(...)
 |      a.setflags(write=None, align=None, uic=None)
 |      
 |      Set array flags WRITEABLE, ALIGNED, (WRITEBACKIFCOPY and UPDATEIFCOPY),
 |      respectively.
 |      
 |      These Boolean-valued flags affect how numpy interprets the memory
 |      area used by `a` (see Notes below). The ALIGNED flag can only
 |      be set to True if the data is actually aligned according to the type.
 |      The WRITEBACKIFCOPY and (deprecated) UPDATEIFCOPY flags can never be set
 |      to True. The flag WRITEABLE can only be set to True if the array owns its
 |      own memory, or the ultimate owner of the memory exposes a writeable buffer
 |      interface, or is a string. (The exception for string is made so that
 |      unpickling can be done without copying memory.)
 |      
 |      Parameters
 |      ----------
 |      write : bool, optional
 |          Describes whether or not `a` can be written to.
 |      align : bool, optional
 |          Describes whether or not `a` is aligned properly for its type.
 |      uic : bool, optional
 |          Describes whether or not `a` is a copy of another ""base"" array.
 |      
 |      Notes
 |      -----
 |      Array flags provide information about how the memory area used
 |      for the array is to be interpreted. There are 7 Boolean flags
 |      in use, only four of which can be changed by the user:
 |      WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED.
 |      
 |      WRITEABLE (W) the data area can be written to;
 |      
 |      ALIGNED (A) the data and strides are aligned appropriately for the hardware
 |      (as determined by the compiler);
 |      
 |      UPDATEIFCOPY (U) (deprecated), replaced by WRITEBACKIFCOPY;
 |      
 |      WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced
 |      by .base). When the C-API function PyArray_ResolveWritebackIfCopy is
 |      called, the base array will be updated with the contents of this array.
 |      
 |      All flags can be accessed using the single (upper case) letter as well
 |      as the full name.
 |      
 |      Examples
 |      --------
 |      >>> y
 |      array([[3, 1, 7],
 |             [2, 0, 0],
 |             [8, 5, 9]])
 |      >>> y.flags
 |        C_CONTIGUOUS : True
 |        F_CONTIGUOUS : False
 |        OWNDATA : True
 |        WRITEABLE : True
 |        ALIGNED : True
 |        WRITEBACKIFCOPY : False
 |        UPDATEIFCOPY : False
 |      >>> y.setflags(write=0, align=0)
 |      >>> y.flags
 |        C_CONTIGUOUS : True
 |        F_CONTIGUOUS : False
 |        OWNDATA : True
 |        WRITEABLE : False
 |        ALIGNED : False
 |        WRITEBACKIFCOPY : False
 |        UPDATEIFCOPY : False
 |      >>> y.setflags(uic=1)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: cannot set WRITEBACKIFCOPY flag to True
 |  
 |  sort(...)
 |      a.sort(axis=-1, kind='quicksort', order=None)
 |      
 |      Sort an array, in-place.
 |      
 |      Parameters
 |      ----------
 |      axis : int, optional
 |          Axis along which to sort. Default is -1, which means sort along the
 |          last axis.
 |      kind : {'quicksort', 'mergesort', 'heapsort'}, optional
 |          Sorting algorithm. Default is 'quicksort'.
 |      order : str or list of str, optional
 |          When `a` is an array with fields defined, this argument specifies
 |          which fields to compare first, second, etc.  A single field can
 |          be specified as a string, and not all fields need be specified,
 |          but unspecified fields will still be used, in the order in which
 |          they come up in the dtype, to break ties.
 |      
 |      See Also
 |      --------
 |      numpy.sort : Return a sorted copy of an array.
 |      argsort : Indirect sort.
 |      lexsort : Indirect stable sort on multiple keys.
 |      searchsorted : Find elements in sorted array.
 |      partition: Partial sort.
 |      
 |      Notes
 |      -----
 |      See ``sort`` for notes on the different sorting algorithms.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1,4], [3,1]])
 |      >>> a.sort(axis=1)
 |      >>> a
 |      array([[1, 4],
 |             [1, 3]])
 |      >>> a.sort(axis=0)
 |      >>> a
 |      array([[1, 3],
 |             [1, 4]])
 |      
 |      Use the `order` keyword to specify a field to use when sorting a
 |      structured array:
 |      
 |      >>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])
 |      >>> a.sort(order='y')
 |      >>> a
 |      array([('c', 1), ('a', 2)],
 |            dtype=[('x', '|S1'), ('y', '<i4')])
 |  
 |  squeeze(...)
 |      a.squeeze(axis=None)
 |      
 |      Remove single-dimensional entries from the shape of `a`.
 |      
 |      Refer to `numpy.squeeze` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.squeeze : equivalent function
 |  
 |  std(...)
 |      a.std(axis=None, dtype=None, out=None, ddof=0, keepdims=False)
 |      
 |      Returns the standard deviation of the array elements along given axis.
 |      
 |      Refer to `numpy.std` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.std : equivalent function
 |  
 |  sum(...)
 |      a.sum(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Return the sum of the array elements over the given axis.
 |      
 |      Refer to `numpy.sum` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.sum : equivalent function
 |  
 |  swapaxes(...)
 |      a.swapaxes(axis1, axis2)
 |      
 |      Return a view of the array with `axis1` and `axis2` interchanged.
 |      
 |      Refer to `numpy.swapaxes` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.swapaxes : equivalent function
 |  
 |  take(...)
 |      a.take(indices, axis=None, out=None, mode='raise')
 |      
 |      Return an array formed from the elements of `a` at the given indices.
 |      
 |      Refer to `numpy.take` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.take : equivalent function
 |  
 |  tobytes(...)
 |      a.tobytes(order='C')
 |      
 |      Construct Python bytes containing the raw data bytes in the array.
 |      
 |      Constructs Python bytes showing a copy of the raw contents of
 |      data memory. The bytes object can be produced in either 'C' or 'Fortran',
 |      or 'Any' order (the default is 'C'-order). 'Any' order means C-order
 |      unless the F_CONTIGUOUS flag in the array is set, in which case it
 |      means 'Fortran' order.
 |      
 |      .. versionadded:: 1.9.0
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', None}, optional
 |          Order of the data for multidimensional arrays:
 |          C, Fortran, or the same as for the original array.
 |      
 |      Returns
 |      -------
 |      s : bytes
 |          Python bytes exhibiting a copy of `a`'s raw data.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[0, 1], [2, 3]])
 |      >>> x.tobytes()
 |      b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
 |      >>> x.tobytes('C') == x.tobytes()
 |      True
 |      >>> x.tobytes('F')
 |      b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
 |  
 |  tofile(...)
 |      a.tofile(fid, sep="""", format=""%s"")
 |      
 |      Write array to a file as text or binary (default).
 |      
 |      Data is always written in 'C' order, independent of the order of `a`.
 |      The data produced by this method can be recovered using the function
 |      fromfile().
 |      
 |      Parameters
 |      ----------
 |      fid : file or str
 |          An open file object, or a string containing a filename.
 |      sep : str
 |          Separator between array items for text output.
 |          If """" (empty), a binary file is written, equivalent to
 |          ``file.write(a.tobytes())``.
 |      format : str
 |          Format string for text file output.
 |          Each entry in the array is formatted to text by first converting
 |          it to the closest Python type, and then using ""format"" % item.
 |      
 |      Notes
 |      -----
 |      This is a convenience function for quick storage of array data.
 |      Information on endianness and precision is lost, so this method is not a
 |      good choice for files intended to archive data or transport data between
 |      machines with different endianness. Some of these problems can be overcome
 |      by outputting the data as text files, at the expense of speed and file
 |      size.
 |  
 |  tolist(...)
 |      a.tolist()
 |      
 |      Return the array as a (possibly nested) list.
 |      
 |      Return a copy of the array data as a (nested) Python list.
 |      Data items are converted to the nearest compatible Python type.
 |      
 |      Parameters
 |      ----------
 |      none
 |      
 |      Returns
 |      -------
 |      y : list
 |          The possibly nested list of array elements.
 |      
 |      Notes
 |      -----
 |      The array may be recreated, ``a = np.array(a.tolist())``.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([1, 2])
 |      >>> a.tolist()
 |      [1, 2]
 |      >>> a = np.array([[1, 2], [3, 4]])
 |      >>> list(a)
 |      [array([1, 2]), array([3, 4])]
 |      >>> a.tolist()
 |      [[1, 2], [3, 4]]
 |  
 |  tostring(...)
 |      a.tostring(order='C')
 |      
 |      Construct Python bytes containing the raw data bytes in the array.
 |      
 |      Constructs Python bytes showing a copy of the raw contents of
 |      data memory. The bytes object can be produced in either 'C' or 'Fortran',
 |      or 'Any' order (the default is 'C'-order). 'Any' order means C-order
 |      unless the F_CONTIGUOUS flag in the array is set, in which case it
 |      means 'Fortran' order.
 |      
 |      This function is a compatibility alias for tobytes. Despite its name it returns bytes not strings.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', None}, optional
 |          Order of the data for multidimensional arrays:
 |          C, Fortran, or the same as for the original array.
 |      
 |      Returns
 |      -------
 |      s : bytes
 |          Python bytes exhibiting a copy of `a`'s raw data.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[0, 1], [2, 3]])
 |      >>> x.tobytes()
 |      b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
 |      >>> x.tobytes('C') == x.tobytes()
 |      True
 |      >>> x.tobytes('F')
 |      b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
 |  
 |  trace(...)
 |      a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)
 |      
 |      Return the sum along diagonals of the array.
 |      
 |      Refer to `numpy.trace` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.trace : equivalent function
 |  
 |  transpose(...)
 |      a.transpose(*axes)
 |      
 |      Returns a view of the array with axes transposed.
 |      
 |      For a 1-D array, this has no effect. (To change between column and
 |      row vectors, first cast the 1-D array into a matrix object.)
 |      For a 2-D array, this is the usual matrix transpose.
 |      For an n-D array, if axes are given, their order indicates how the
 |      axes are permuted (see Examples). If axes are not provided and
 |      ``a.shape = (i[0], i[1], ... i[n-2], i[n-1])``, then
 |      ``a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0])``.
 |      
 |      Parameters
 |      ----------
 |      axes : None, tuple of ints, or `n` ints
 |      
 |       * None or no argument: reverses the order of the axes.
 |      
 |       * tuple of ints: `i` in the `j`-th place in the tuple means `a`'s
 |         `i`-th axis becomes `a.transpose()`'s `j`-th axis.
 |      
 |       * `n` ints: same as an n-tuple of the same ints (this form is
 |         intended simply as a ""convenience"" alternative to the tuple form)
 |      
 |      Returns
 |      -------
 |      out : ndarray
 |          View of `a`, with axes suitably permuted.
 |      
 |      See Also
 |      --------
 |      ndarray.T : Array property returning the array transposed.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1, 2], [3, 4]])
 |      >>> a
 |      array([[1, 2],
 |             [3, 4]])
 |      >>> a.transpose()
 |      array([[1, 3],
 |             [2, 4]])
 |      >>> a.transpose((1, 0))
 |      array([[1, 3],
 |             [2, 4]])
 |      >>> a.transpose(1, 0)
 |      array([[1, 3],
 |             [2, 4]])
 |  
 |  var(...)
 |      a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False)
 |      
 |      Returns the variance of the array elements, along given axis.
 |      
 |      Refer to `numpy.var` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.var : equivalent function
 |  
 |  view(...)
 |      a.view(dtype=None, type=None)
 |      
 |      New view of array with the same data.
 |      
 |      Parameters
 |      ----------
 |      dtype : data-type or ndarray sub-class, optional
 |          Data-type descriptor of the returned view, e.g., float32 or int16. The
 |          default, None, results in the view having the same data-type as `a`.
 |          This argument can also be specified as an ndarray sub-class, which
 |          then specifies the type of the returned object (this is equivalent to
 |          setting the ``type`` parameter).
 |      type : Python type, optional
 |          Type of the returned view, e.g., ndarray or matrix.  Again, the
 |          default None results in type preservation.
 |      
 |      Notes
 |      -----
 |      ``a.view()`` is used two different ways:
 |      
 |      ``a.view(some_dtype)`` or ``a.view(dtype=some_dtype)`` constructs a view
 |      of the array's memory with a different data-type.  This can cause a
 |      reinterpretation of the bytes of memory.
 |      
 |      ``a.view(ndarray_subclass)`` or ``a.view(type=ndarray_subclass)`` just
 |      returns an instance of `ndarray_subclass` that looks at the same array
 |      (same shape, dtype, etc.)  This does not cause a reinterpretation of the
 |      memory.
 |      
 |      For ``a.view(some_dtype)``, if ``some_dtype`` has a different number of
 |      bytes per entry than the previous dtype (for example, converting a
 |      regular array to a structured array), then the behavior of the view
 |      cannot be predicted just from the superficial appearance of ``a`` (shown
 |      by ``print(a)``). It also depends on exactly how ``a`` is stored in
 |      memory. Therefore if ``a`` is C-ordered versus fortran-ordered, versus
 |      defined as a slice or transpose, etc., the view may give different
 |      results.
 |      
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])
 |      
 |      Viewing array data using a different type and dtype:
 |      
 |      >>> y = x.view(dtype=np.int16, type=np.matrix)
 |      >>> y
 |      matrix([[513]], dtype=int16)
 |      >>> print(type(y))
 |      <class 'numpy.matrixlib.defmatrix.matrix'>
 |      
 |      Creating a view on a structured array so it can be used in calculations
 |      
 |      >>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)])
 |      >>> xv = x.view(dtype=np.int8).reshape(-1,2)
 |      >>> xv
 |      array([[1, 2],
 |             [3, 4]], dtype=int8)
 |      >>> xv.mean(0)
 |      array([ 2.,  3.])
 |      
 |      Making changes to the view changes the underlying array
 |      
 |      >>> xv[0,1] = 20
 |      >>> print(x)
 |      [(1, 20) (3, 4)]
 |      
 |      Using a view to convert an array to a recarray:
 |      
 |      >>> z = x.view(np.recarray)
 |      >>> z.a
 |      array([1], dtype=int8)
 |      
 |      Views share data:
 |      
 |      >>> x[0] = (9, 10)
 |      >>> z[0]
 |      (9, 10)
 |      
 |      Views that change the dtype size (bytes per entry) should normally be
 |      avoided on arrays defined by slices, transposes, fortran-ordering, etc.:
 |      
 |      >>> x = np.array([[1,2,3],[4,5,6]], dtype=np.int16)
 |      >>> y = x[:, 0:2]
 |      >>> y
 |      array([[1, 2],
 |             [4, 5]], dtype=int16)
 |      >>> y.view(dtype=[('width', np.int16), ('length', np.int16)])
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: new type not compatible with array.
 |      >>> z = y.copy()
 |      >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
 |      array([[(1, 2)],
 |             [(4, 5)]], dtype=[('width', '<i2'), ('length', '<i2')])
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from numpy.ndarray:
 |  
 |  T
 |      Same as self.transpose(), except that self is returned if
 |      self.ndim < 2.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[1.,2.],[3.,4.]])
 |      >>> x
 |      array([[ 1.,  2.],
 |             [ 3.,  4.]])
 |      >>> x.T
 |      array([[ 1.,  3.],
 |             [ 2.,  4.]])
 |      >>> x = np.array([1.,2.,3.,4.])
 |      >>> x
 |      array([ 1.,  2.,  3.,  4.])
 |      >>> x.T
 |      array([ 1.,  2.,  3.,  4.])
 |  
 |  __array_finalize__
 |      None.
 |  
 |  __array_interface__
 |      Array protocol: Python side.
 |  
 |  __array_priority__
 |      Array priority.
 |  
 |  __array_struct__
 |      Array protocol: C-struct side.
 |  
 |  base
 |      Base object if memory is from some other object.
 |      
 |      Examples
 |      --------
 |      The base of an array that owns its memory is None:
 |      
 |      >>> x = np.array([1,2,3,4])
 |      >>> x.base is None
 |      True
 |      
 |      Slicing creates a view, whose memory is shared with x:
 |      
 |      >>> y = x[2:]
 |      >>> y.base is x
 |      True
 |  
 |  ctypes
 |      An object to simplify the interaction of the array with the ctypes
 |      module.
 |      
 |      This attribute creates an object that makes it easier to use arrays
 |      when calling shared libraries with the ctypes module. The returned
 |      object has, among others, data, shape, and strides attributes (see
 |      Notes below) which themselves return ctypes objects that can be used
 |      as arguments to a shared library.
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      c : Python object
 |          Possessing attributes data, shape, strides, etc.
 |      
 |      See Also
 |      --------
 |      numpy.ctypeslib
 |      
 |      Notes
 |      -----
 |      Below are the public attributes of this object which were documented
 |      in ""Guide to NumPy"" (we have omitted undocumented public attributes,
 |      as well as documented private attributes):
 |      
 |      * data: A pointer to the memory area of the array as a Python integer.
 |        This memory area may contain data that is not aligned, or not in correct
 |        byte-order. The memory area may not even be writeable. The array
 |        flags and data-type of this array should be respected when passing this
 |        attribute to arbitrary C-code to avoid trouble that can include Python
 |        crashing. User Beware! The value of this attribute is exactly the same
 |        as self._array_interface_['data'][0].
 |      
 |      * shape (c_intp*self.ndim): A ctypes array of length self.ndim where
 |        the basetype is the C-integer corresponding to dtype('p') on this
 |        platform. This base-type could be c_int, c_long, or c_longlong
 |        depending on the platform. The c_intp type is defined accordingly in
 |        numpy.ctypeslib. The ctypes array contains the shape of the underlying
 |        array.
 |      
 |      * strides (c_intp*self.ndim): A ctypes array of length self.ndim where
 |        the basetype is the same as for the shape attribute. This ctypes array
 |        contains the strides information from the underlying array. This strides
 |        information is important for showing how many bytes must be jumped to
 |        get to the next element in the array.
 |      
 |      * data_as(obj): Return the data pointer cast to a particular c-types object.
 |        For example, calling self._as_parameter_ is equivalent to
 |        self.data_as(ctypes.c_void_p). Perhaps you want to use the data as a
 |        pointer to a ctypes array of floating-point data:
 |        self.data_as(ctypes.POINTER(ctypes.c_double)).
 |      
 |      * shape_as(obj): Return the shape tuple as an array of some other c-types
 |        type. For example: self.shape_as(ctypes.c_short).
 |      
 |      * strides_as(obj): Return the strides tuple as an array of some other
 |        c-types type. For example: self.strides_as(ctypes.c_longlong).
 |      
 |      Be careful using the ctypes attribute - especially on temporary
 |      arrays or arrays constructed on the fly. For example, calling
 |      ``(a+b).ctypes.data_as(ctypes.c_void_p)`` returns a pointer to memory
 |      that is invalid because the array created as (a+b) is deallocated
 |      before the next Python statement. You can avoid this problem using
 |      either ``c=a+b`` or ``ct=(a+b).ctypes``. In the latter case, ct will
 |      hold a reference to the array until ct is deleted or re-assigned.
 |      
 |      If the ctypes module is not available, then the ctypes attribute
 |      of array objects still returns something useful, but ctypes objects
 |      are not returned and errors may be raised instead. In particular,
 |      the object will still have the as parameter attribute which will
 |      return an integer equal to the data attribute.
 |      
 |      Examples
 |      --------
 |      >>> import ctypes
 |      >>> x
 |      array([[0, 1],
 |             [2, 3]])
 |      >>> x.ctypes.data
 |      30439712
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long))
 |      <ctypes.LP_c_long object at 0x01F01300>
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)).contents
 |      c_long(0)
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_longlong)).contents
 |      c_longlong(4294967296L)
 |      >>> x.ctypes.shape
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FFD580>
 |      >>> x.ctypes.shape_as(ctypes.c_long)
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
 |      >>> x.ctypes.strides
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
 |      >>> x.ctypes.strides_as(ctypes.c_longlong)
 |      <numpy.core._internal.c_longlong_Array_2 object at 0x01F01300>
 |  
 |  data
 |      Python buffer object pointing to the start of the array's data.
 |  
 |  dtype
 |      Data-type of the array's elements.
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      d : numpy dtype object
 |      
 |      See Also
 |      --------
 |      numpy.dtype
 |      
 |      Examples
 |      --------
 |      >>> x
 |      array([[0, 1],
 |             [2, 3]])
 |      >>> x.dtype
 |      dtype('int32')
 |      >>> type(x.dtype)
 |      <type 'numpy.dtype'>
 |  
 |  flags
 |      Information about the memory layout of the array.
 |      
 |      Attributes
 |      ----------
 |      C_CONTIGUOUS (C)
 |          The data is in a single, C-style contiguous segment.
 |      F_CONTIGUOUS (F)
 |          The data is in a single, Fortran-style contiguous segment.
 |      OWNDATA (O)
 |          The array owns the memory it uses or borrows it from another object.
 |      WRITEABLE (W)
 |          The data area can be written to.  Setting this to False locks
 |          the data, making it read-only.  A view (slice, etc.) inherits WRITEABLE
 |          from its base array at creation time, but a view of a writeable
 |          array may be subsequently locked while the base array remains writeable.
 |          (The opposite is not true, in that a view of a locked array may not
 |          be made writeable.  However, currently, locking a base object does not
 |          lock any views that already reference it, so under that circumstance it
 |          is possible to alter the contents of a locked array via a previously
 |          created writeable view onto it.)  Attempting to change a non-writeable
 |          array raises a RuntimeError exception.
 |      ALIGNED (A)
 |          The data and all elements are aligned appropriately for the hardware.
 |      WRITEBACKIFCOPY (X)
 |          This array is a copy of some other array. The C-API function
 |          PyArray_ResolveWritebackIfCopy must be called before deallocating
 |          to the base array will be updated with the contents of this array.
 |      UPDATEIFCOPY (U)
 |          (Deprecated, use WRITEBACKIFCOPY) This array is a copy of some other array.
 |          When this array is
 |          deallocated, the base array will be updated with the contents of
 |          this array.
 |      FNC
 |          F_CONTIGUOUS and not C_CONTIGUOUS.
 |      FORC
 |          F_CONTIGUOUS or C_CONTIGUOUS (one-segment test).
 |      BEHAVED (B)
 |          ALIGNED and WRITEABLE.
 |      CARRAY (CA)
 |          BEHAVED and C_CONTIGUOUS.
 |      FARRAY (FA)
 |          BEHAVED and F_CONTIGUOUS and not C_CONTIGUOUS.
 |      
 |      Notes
 |      -----
 |      The `flags` object can be accessed dictionary-like (as in ``a.flags['WRITEABLE']``),
 |      or by using lowercased attribute names (as in ``a.flags.writeable``). Short flag
 |      names are only supported in dictionary access.
 |      
 |      Only the WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED flags can be
 |      changed by the user, via direct assignment to the attribute or dictionary
 |      entry, or by calling `ndarray.setflags`.
 |      
 |      The array flags cannot be set arbitrarily:
 |      
 |      - UPDATEIFCOPY can only be set ``False``.
 |      - WRITEBACKIFCOPY can only be set ``False``.
 |      - ALIGNED can only be set ``True`` if the data is truly aligned.
 |      - WRITEABLE can only be set ``True`` if the array owns its own memory
 |        or the ultimate owner of the memory exposes a writeable buffer
 |        interface or is a string.
 |      
 |      Arrays can be both C-style and Fortran-style contiguous simultaneously.
 |      This is clear for 1-dimensional arrays, but can also be true for higher
 |      dimensional arrays.
 |      
 |      Even for contiguous arrays a stride for a given dimension
 |      ``arr.strides[dim]`` may be *arbitrary* if ``arr.shape[dim] == 1``
 |      or the array has no elements.
 |      It does *not* generally hold that ``self.strides[-1] == self.itemsize``
 |      for C-style contiguous arrays or ``self.strides[0] == self.itemsize`` for
 |      Fortran-style contiguous arrays is true.
 |  
 |  flat
 |      A 1-D iterator over the array.
 |      
 |      This is a `numpy.flatiter` instance, which acts similarly to, but is not
 |      a subclass of, Python's built-in iterator object.
 |      
 |      See Also
 |      --------
 |      flatten : Return a copy of the array collapsed into one dimension.
 |      
 |      flatiter
 |      
 |      Examples
 |      --------
 |      >>> x = np.arange(1, 7).reshape(2, 3)
 |      >>> x
 |      array([[1, 2, 3],
 |             [4, 5, 6]])
 |      >>> x.flat[3]
 |      4
 |      >>> x.T
 |      array([[1, 4],
 |             [2, 5],
 |             [3, 6]])
 |      >>> x.T.flat[3]
 |      5
 |      >>> type(x.flat)
 |      <type 'numpy.flatiter'>
 |      
 |      An assignment example:
 |      
 |      >>> x.flat = 3; x
 |      array([[3, 3, 3],
 |             [3, 3, 3]])
 |      >>> x.flat[[1,4]] = 1; x
 |      array([[3, 1, 3],
 |             [3, 1, 3]])
 |  
 |  imag
 |      The imaginary part of the array.
 |      
 |      Examples
 |      --------
 |      >>> x = np.sqrt([1+0j, 0+1j])
 |      >>> x.imag
 |      array([ 0.        ,  0.70710678])
 |      >>> x.imag.dtype
 |      dtype('float64')
 |  
 |  itemsize
 |      Length of one array element in bytes.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1,2,3], dtype=np.float64)
 |      >>> x.itemsize
 |      8
 |      >>> x = np.array([1,2,3], dtype=np.complex128)
 |      >>> x.itemsize
 |      16
 |  
 |  nbytes
 |      Total bytes consumed by the elements of the array.
 |      
 |      Notes
 |      -----
 |      Does not include memory consumed by non-element attributes of the
 |      array object.
 |      
 |      Examples
 |      --------
 |      >>> x = np.zeros((3,5,2), dtype=np.complex128)
 |      >>> x.nbytes
 |      480
 |      >>> np.prod(x.shape) * x.itemsize
 |      480
 |  
 |  ndim
 |      Number of array dimensions.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 3])
 |      >>> x.ndim
 |      1
 |      >>> y = np.zeros((2, 3, 4))
 |      >>> y.ndim
 |      3
 |  
 |  real
 |      The real part of the array.
 |      
 |      Examples
 |      --------
 |      >>> x = np.sqrt([1+0j, 0+1j])
 |      >>> x.real
 |      array([ 1.        ,  0.70710678])
 |      >>> x.real.dtype
 |      dtype('float64')
 |      
 |      See Also
 |      --------
 |      numpy.real : equivalent function
 |  
 |  shape
 |      Tuple of array dimensions.
 |      
 |      The shape property is usually used to get the current shape of an array,
 |      but may also be used to reshape the array in-place by assigning a tuple of
 |      array dimensions to it.  As with `numpy.reshape`, one of the new shape
 |      dimensions can be -1, in which case its value is inferred from the size of
 |      the array and the remaining dimensions. Reshaping an array in-place will
 |      fail if a copy is required.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 3, 4])
 |      >>> x.shape
 |      (4,)
 |      >>> y = np.zeros((2, 3, 4))
 |      >>> y.shape
 |      (2, 3, 4)
 |      >>> y.shape = (3, 8)
 |      >>> y
 |      array([[ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
 |             [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
 |             [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.]])
 |      >>> y.shape = (3, 6)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: total size of new array must be unchanged
 |      >>> np.zeros((4,2))[::2].shape = (-1,)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      AttributeError: incompatible shape for a non-contiguous array
 |      
 |      See Also
 |      --------
 |      numpy.reshape : similar function
 |      ndarray.reshape : similar method
 |  
 |  size
 |      Number of elements in the array.
 |      
 |      Equivalent to ``np.prod(a.shape)``, i.e., the product of the array's
 |      dimensions.
 |      
 |      Examples
 |      --------
 |      >>> x = np.zeros((3, 5, 2), dtype=np.complex128)
 |      >>> x.size
 |      30
 |      >>> np.prod(x.shape)
 |      30
 |  
 |  strides
 |      Tuple of bytes to step in each dimension when traversing an array.
 |      
 |      The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a`
 |      is::
 |      
 |          offset = sum(np.array(i) * a.strides)
 |      
 |      A more detailed explanation of strides can be found in the
 |      ""ndarray.rst"" file in the NumPy reference guide.
 |      
 |      Notes
 |      -----
 |      Imagine an array of 32-bit integers (each 4 bytes)::
 |      
 |        x = np.array([[0, 1, 2, 3, 4],
 |                      [5, 6, 7, 8, 9]], dtype=np.int32)
 |      
 |      This array is stored in memory as 40 bytes, one after the other
 |      (known as a contiguous block of memory).  The strides of an array tell
 |      us how many bytes we have to skip in memory to move to the next position
 |      along a certain axis.  For example, we have to skip 4 bytes (1 value) to
 |      move to the next column, but 20 bytes (5 values) to get to the same
 |      position in the next row.  As such, the strides for the array `x` will be
 |      ``(20, 4)``.
 |      
 |      See Also
 |      --------
 |      numpy.lib.stride_tricks.as_strided
 |      
 |      Examples
 |      --------
 |      >>> y = np.reshape(np.arange(2*3*4), (2,3,4))
 |      >>> y
 |      array([[[ 0,  1,  2,  3],
 |              [ 4,  5,  6,  7],
 |              [ 8,  9, 10, 11]],
 |             [[12, 13, 14, 15],
 |              [16, 17, 18, 19],
 |              [20, 21, 22, 23]]])
 |      >>> y.strides
 |      (48, 16, 4)
 |      >>> y[1,1,1]
 |      17
 |      >>> offset=sum(y.strides * np.array((1,1,1)))
 |      >>> offset/y.itemsize
 |      17
 |      
 |      >>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0)
 |      >>> x.strides
 |      (32, 4, 224, 1344)
 |      >>> i = np.array([3,5,2,2])
 |      >>> offset = sum(i * x.strides)
 |      >>> x[3,5,2,2]
 |      813
 |      >>> offset / x.itemsize
 |      813
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from numpy.ndarray:
 |  
 |  __hash__ = None
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.matlab.mio5_params.MatlabObject,io.matlab.mio5_params,MatlabObject,"Python Library Documentation: class MatlabObject in module scipy.io.matlab.mio5_params

class MatlabObject(numpy.ndarray)
 |  ndarray Subclass to contain matlab object
 |  
 |  Method resolution order:
 |      MatlabObject
 |      numpy.ndarray
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __array_finalize__(self, obj)
 |      None.
 |  
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |  
 |  __new__(cls, input_array, classname=None)
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from numpy.ndarray:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __array__(...)
 |      a.__array__(|dtype) -> reference if type unchanged, copy otherwise.
 |      
 |      Returns either a new reference to self if dtype is not given or a new array
 |      of provided data type if dtype is different from the current dtype of the
 |      array.
 |  
 |  __array_prepare__(...)
 |      a.__array_prepare__(obj) -> Object of same type as ndarray object obj.
 |  
 |  __array_ufunc__(...)
 |  
 |  __array_wrap__(...)
 |      a.__array_wrap__(obj) -> Object of same type as ndarray object a.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __complex__(...)
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __copy__(...)
 |      a.__copy__()
 |      
 |      Used if :func:`copy.copy` is called on an array. Returns a copy of the array.
 |      
 |      Equivalent to ``a.copy(order='K')``.
 |  
 |  __deepcopy__(...)
 |      a.__deepcopy__(memo, /) -> Deep copy of array.
 |      
 |      Used if :func:`copy.deepcopy` is called on an array.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __format__(...)
 |      default object formatter
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iadd__(self, value, /)
 |      Return self+=value.
 |  
 |  __iand__(self, value, /)
 |      Return self&=value.
 |  
 |  __ifloordiv__(self, value, /)
 |      Return self//=value.
 |  
 |  __ilshift__(self, value, /)
 |      Return self<<=value.
 |  
 |  __imatmul__(self, value, /)
 |      Return self@=value.
 |  
 |  __imod__(self, value, /)
 |      Return self%=value.
 |  
 |  __imul__(self, value, /)
 |      Return self*=value.
 |  
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __ior__(self, value, /)
 |      Return self|=value.
 |  
 |  __ipow__(self, value, /)
 |      Return self**=value.
 |  
 |  __irshift__(self, value, /)
 |      Return self>>=value.
 |  
 |  __isub__(self, value, /)
 |      Return self-=value.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __itruediv__(self, value, /)
 |      Return self/=value.
 |  
 |  __ixor__(self, value, /)
 |      Return self^=value.
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __matmul__(self, value, /)
 |      Return self@value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __reduce__(...)
 |      a.__reduce__()
 |      
 |      For pickling.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmatmul__(self, value, /)
 |      Return value@self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __setstate__(...)
 |      a.__setstate__(state, /)
 |      
 |      For unpickling.
 |      
 |      The `state` argument must be a sequence that contains the following
 |      elements:
 |      
 |      Parameters
 |      ----------
 |      version : int
 |          optional pickle version. If omitted defaults to 0.
 |      shape : tuple
 |      dtype : data-type
 |      isFortran : bool
 |      rawdata : string or list
 |          a binary string with the data (or a list if 'a' is an object array)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  all(...)
 |      a.all(axis=None, out=None, keepdims=False)
 |      
 |      Returns True if all elements evaluate to True.
 |      
 |      Refer to `numpy.all` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.all : equivalent function
 |  
 |  any(...)
 |      a.any(axis=None, out=None, keepdims=False)
 |      
 |      Returns True if any of the elements of `a` evaluate to True.
 |      
 |      Refer to `numpy.any` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.any : equivalent function
 |  
 |  argmax(...)
 |      a.argmax(axis=None, out=None)
 |      
 |      Return indices of the maximum values along the given axis.
 |      
 |      Refer to `numpy.argmax` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argmax : equivalent function
 |  
 |  argmin(...)
 |      a.argmin(axis=None, out=None)
 |      
 |      Return indices of the minimum values along the given axis of `a`.
 |      
 |      Refer to `numpy.argmin` for detailed documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argmin : equivalent function
 |  
 |  argpartition(...)
 |      a.argpartition(kth, axis=-1, kind='introselect', order=None)
 |      
 |      Returns the indices that would partition this array.
 |      
 |      Refer to `numpy.argpartition` for full documentation.
 |      
 |      .. versionadded:: 1.8.0
 |      
 |      See Also
 |      --------
 |      numpy.argpartition : equivalent function
 |  
 |  argsort(...)
 |      a.argsort(axis=-1, kind='quicksort', order=None)
 |      
 |      Returns the indices that would sort this array.
 |      
 |      Refer to `numpy.argsort` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argsort : equivalent function
 |  
 |  astype(...)
 |      a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)
 |      
 |      Copy of the array, cast to a specified type.
 |      
 |      Parameters
 |      ----------
 |      dtype : str or dtype
 |          Typecode or data-type to which the array is cast.
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          Controls the memory layout order of the result.
 |          'C' means C order, 'F' means Fortran order, 'A'
 |          means 'F' order if all the arrays are Fortran contiguous,
 |          'C' order otherwise, and 'K' means as close to the
 |          order the array elements appear in memory as possible.
 |          Default is 'K'.
 |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
 |          Controls what kind of data casting may occur. Defaults to 'unsafe'
 |          for backwards compatibility.
 |      
 |            * 'no' means the data types should not be cast at all.
 |            * 'equiv' means only byte-order changes are allowed.
 |            * 'safe' means only casts which can preserve values are allowed.
 |            * 'same_kind' means only safe casts or casts within a kind,
 |              like float64 to float32, are allowed.
 |            * 'unsafe' means any data conversions may be done.
 |      subok : bool, optional
 |          If True, then sub-classes will be passed-through (default), otherwise
 |          the returned array will be forced to be a base-class array.
 |      copy : bool, optional
 |          By default, astype always returns a newly allocated array. If this
 |          is set to false, and the `dtype`, `order`, and `subok`
 |          requirements are satisfied, the input array is returned instead
 |          of a copy.
 |      
 |      Returns
 |      -------
 |      arr_t : ndarray
 |          Unless `copy` is False and the other conditions for returning the input
 |          array are satisfied (see description for `copy` input parameter), `arr_t`
 |          is a new array of the same shape as the input array, with dtype, order
 |          given by `dtype`, `order`.
 |      
 |      Notes
 |      -----
 |      Starting in NumPy 1.9, astype method now returns an error if the string
 |      dtype to cast to is not long enough in 'safe' casting mode to hold the max
 |      value of integer/float array that is being casted. Previously the casting
 |      was allowed even if the result was truncated.
 |      
 |      Raises
 |      ------
 |      ComplexWarning
 |          When casting from complex to float or int. To avoid this,
 |          one should use ``a.real.astype(t)``.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 2.5])
 |      >>> x
 |      array([ 1. ,  2. ,  2.5])
 |      
 |      >>> x.astype(int)
 |      array([1, 2, 2])
 |  
 |  byteswap(...)
 |      a.byteswap(inplace=False)
 |      
 |      Swap the bytes of the array elements
 |      
 |      Toggle between low-endian and big-endian data representation by
 |      returning a byteswapped array, optionally swapped in-place.
 |      
 |      Parameters
 |      ----------
 |      inplace : bool, optional
 |          If ``True``, swap bytes in-place, default is ``False``.
 |      
 |      Returns
 |      -------
 |      out : ndarray
 |          The byteswapped array. If `inplace` is ``True``, this is
 |          a view to self.
 |      
 |      Examples
 |      --------
 |      >>> A = np.array([1, 256, 8755], dtype=np.int16)
 |      >>> map(hex, A)
 |      ['0x1', '0x100', '0x2233']
 |      >>> A.byteswap(inplace=True)
 |      array([  256,     1, 13090], dtype=int16)
 |      >>> map(hex, A)
 |      ['0x100', '0x1', '0x3322']
 |      
 |      Arrays of strings are not swapped
 |      
 |      >>> A = np.array(['ceg', 'fac'])
 |      >>> A.byteswap()
 |      array(['ceg', 'fac'],
 |            dtype='|S3')
 |  
 |  choose(...)
 |      a.choose(choices, out=None, mode='raise')
 |      
 |      Use an index array to construct a new array from a set of choices.
 |      
 |      Refer to `numpy.choose` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.choose : equivalent function
 |  
 |  clip(...)
 |      a.clip(min=None, max=None, out=None)
 |      
 |      Return an array whose values are limited to ``[min, max]``.
 |      One of max or min must be given.
 |      
 |      Refer to `numpy.clip` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.clip : equivalent function
 |  
 |  compress(...)
 |      a.compress(condition, axis=None, out=None)
 |      
 |      Return selected slices of this array along given axis.
 |      
 |      Refer to `numpy.compress` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.compress : equivalent function
 |  
 |  conj(...)
 |      a.conj()
 |      
 |      Complex-conjugate all elements.
 |      
 |      Refer to `numpy.conjugate` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.conjugate : equivalent function
 |  
 |  conjugate(...)
 |      a.conjugate()
 |      
 |      Return the complex conjugate, element-wise.
 |      
 |      Refer to `numpy.conjugate` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.conjugate : equivalent function
 |  
 |  copy(...)
 |      a.copy(order='C')
 |      
 |      Return a copy of the array.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          Controls the memory layout of the copy. 'C' means C-order,
 |          'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
 |          'C' otherwise. 'K' means match the layout of `a` as closely
 |          as possible. (Note that this function and :func:`numpy.copy` are very
 |          similar, but have different default values for their order=
 |          arguments.)
 |      
 |      See also
 |      --------
 |      numpy.copy
 |      numpy.copyto
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[1,2,3],[4,5,6]], order='F')
 |      
 |      >>> y = x.copy()
 |      
 |      >>> x.fill(0)
 |      
 |      >>> x
 |      array([[0, 0, 0],
 |             [0, 0, 0]])
 |      
 |      >>> y
 |      array([[1, 2, 3],
 |             [4, 5, 6]])
 |      
 |      >>> y.flags['C_CONTIGUOUS']
 |      True
 |  
 |  cumprod(...)
 |      a.cumprod(axis=None, dtype=None, out=None)
 |      
 |      Return the cumulative product of the elements along the given axis.
 |      
 |      Refer to `numpy.cumprod` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.cumprod : equivalent function
 |  
 |  cumsum(...)
 |      a.cumsum(axis=None, dtype=None, out=None)
 |      
 |      Return the cumulative sum of the elements along the given axis.
 |      
 |      Refer to `numpy.cumsum` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.cumsum : equivalent function
 |  
 |  diagonal(...)
 |      a.diagonal(offset=0, axis1=0, axis2=1)
 |      
 |      Return specified diagonals. In NumPy 1.9 the returned array is a
 |      read-only view instead of a copy as in previous NumPy versions.  In
 |      a future version the read-only restriction will be removed.
 |      
 |      Refer to :func:`numpy.diagonal` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.diagonal : equivalent function
 |  
 |  dot(...)
 |      a.dot(b, out=None)
 |      
 |      Dot product of two arrays.
 |      
 |      Refer to `numpy.dot` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.dot : equivalent function
 |      
 |      Examples
 |      --------
 |      >>> a = np.eye(2)
 |      >>> b = np.ones((2, 2)) * 2
 |      >>> a.dot(b)
 |      array([[ 2.,  2.],
 |             [ 2.,  2.]])
 |      
 |      This array method can be conveniently chained:
 |      
 |      >>> a.dot(b).dot(b)
 |      array([[ 8.,  8.],
 |             [ 8.,  8.]])
 |  
 |  dump(...)
 |      a.dump(file)
 |      
 |      Dump a pickle of the array to the specified file.
 |      The array can be read back with pickle.load or numpy.load.
 |      
 |      Parameters
 |      ----------
 |      file : str
 |          A string naming the dump file.
 |  
 |  dumps(...)
 |      a.dumps()
 |      
 |      Returns the pickle of the array as a string.
 |      pickle.loads or numpy.loads will convert the string back to an array.
 |      
 |      Parameters
 |      ----------
 |      None
 |  
 |  fill(...)
 |      a.fill(value)
 |      
 |      Fill the array with a scalar value.
 |      
 |      Parameters
 |      ----------
 |      value : scalar
 |          All elements of `a` will be assigned this value.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([1, 2])
 |      >>> a.fill(0)
 |      >>> a
 |      array([0, 0])
 |      >>> a = np.empty(2)
 |      >>> a.fill(1)
 |      >>> a
 |      array([ 1.,  1.])
 |  
 |  flatten(...)
 |      a.flatten(order='C')
 |      
 |      Return a copy of the array collapsed into one dimension.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          'C' means to flatten in row-major (C-style) order.
 |          'F' means to flatten in column-major (Fortran-
 |          style) order. 'A' means to flatten in column-major
 |          order if `a` is Fortran *contiguous* in memory,
 |          row-major order otherwise. 'K' means to flatten
 |          `a` in the order the elements occur in memory.
 |          The default is 'C'.
 |      
 |      Returns
 |      -------
 |      y : ndarray
 |          A copy of the input array, flattened to one dimension.
 |      
 |      See Also
 |      --------
 |      ravel : Return a flattened array.
 |      flat : A 1-D flat iterator over the array.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1,2], [3,4]])
 |      >>> a.flatten()
 |      array([1, 2, 3, 4])
 |      >>> a.flatten('F')
 |      array([1, 3, 2, 4])
 |  
 |  getfield(...)
 |      a.getfield(dtype, offset=0)
 |      
 |      Returns a field of the given array as a certain type.
 |      
 |      A field is a view of the array data with a given data-type. The values in
 |      the view are determined by the given type and the offset into the current
 |      array in bytes. The offset needs to be such that the view dtype fits in the
 |      array dtype; for example an array of dtype complex128 has 16-byte elements.
 |      If taking a view with a 32-bit integer (4 bytes), the offset needs to be
 |      between 0 and 12 bytes.
 |      
 |      Parameters
 |      ----------
 |      dtype : str or dtype
 |          The data type of the view. The dtype size of the view can not be larger
 |          than that of the array itself.
 |      offset : int
 |          Number of bytes to skip before beginning the element view.
 |      
 |      Examples
 |      --------
 |      >>> x = np.diag([1.+1.j]*2)
 |      >>> x[1, 1] = 2 + 4.j
 |      >>> x
 |      array([[ 1.+1.j,  0.+0.j],
 |             [ 0.+0.j,  2.+4.j]])
 |      >>> x.getfield(np.float64)
 |      array([[ 1.,  0.],
 |             [ 0.,  2.]])
 |      
 |      By choosing an offset of 8 bytes we can select the complex part of the
 |      array for our view:
 |      
 |      >>> x.getfield(np.float64, offset=8)
 |      array([[ 1.,  0.],
 |         [ 0.,  4.]])
 |  
 |  item(...)
 |      a.item(*args)
 |      
 |      Copy an element of an array to a standard Python scalar and return it.
 |      
 |      Parameters
 |      ----------
 |      \*args : Arguments (variable number and type)
 |      
 |          * none: in this case, the method only works for arrays
 |            with one element (`a.size == 1`), which element is
 |            copied into a standard Python scalar object and returned.
 |      
 |          * int_type: this argument is interpreted as a flat index into
 |            the array, specifying which element to copy and return.
 |      
 |          * tuple of int_types: functions as does a single int_type argument,
 |            except that the argument is interpreted as an nd-index into the
 |            array.
 |      
 |      Returns
 |      -------
 |      z : Standard Python scalar object
 |          A copy of the specified element of the array as a suitable
 |          Python scalar
 |      
 |      Notes
 |      -----
 |      When the data type of `a` is longdouble or clongdouble, item() returns
 |      a scalar array object because there is no available Python scalar that
 |      would not lose information. Void arrays return a buffer object for item(),
 |      unless fields are defined, in which case a tuple is returned.
 |      
 |      `item` is very similar to a[args], except, instead of an array scalar,
 |      a standard Python scalar is returned. This can be useful for speeding up
 |      access to elements of the array and doing arithmetic on elements of the
 |      array using Python's optimized math.
 |      
 |      Examples
 |      --------
 |      >>> x = np.random.randint(9, size=(3, 3))
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 8, 3],
 |             [8, 5, 3]])
 |      >>> x.item(3)
 |      2
 |      >>> x.item(7)
 |      5
 |      >>> x.item((0, 1))
 |      1
 |      >>> x.item((2, 2))
 |      3
 |  
 |  itemset(...)
 |      a.itemset(*args)
 |      
 |      Insert scalar into an array (scalar is cast to array's dtype, if possible)
 |      
 |      There must be at least 1 argument, and define the last argument
 |      as *item*.  Then, ``a.itemset(*args)`` is equivalent to but faster
 |      than ``a[args] = item``.  The item should be a scalar value and `args`
 |      must select a single item in the array `a`.
 |      
 |      Parameters
 |      ----------
 |      \*args : Arguments
 |          If one argument: a scalar, only used in case `a` is of size 1.
 |          If two arguments: the last argument is the value to be set
 |          and must be a scalar, the first argument specifies a single array
 |          element location. It is either an int or a tuple.
 |      
 |      Notes
 |      -----
 |      Compared to indexing syntax, `itemset` provides some speed increase
 |      for placing a scalar into a particular location in an `ndarray`,
 |      if you must do this.  However, generally this is discouraged:
 |      among other problems, it complicates the appearance of the code.
 |      Also, when using `itemset` (and `item`) inside a loop, be sure
 |      to assign the methods to a local variable to avoid the attribute
 |      look-up at each loop iteration.
 |      
 |      Examples
 |      --------
 |      >>> x = np.random.randint(9, size=(3, 3))
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 8, 3],
 |             [8, 5, 3]])
 |      >>> x.itemset(4, 0)
 |      >>> x.itemset((2, 2), 9)
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 0, 3],
 |             [8, 5, 9]])
 |  
 |  max(...)
 |      a.max(axis=None, out=None, keepdims=False)
 |      
 |      Return the maximum along a given axis.
 |      
 |      Refer to `numpy.amax` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.amax : equivalent function
 |  
 |  mean(...)
 |      a.mean(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Returns the average of the array elements along given axis.
 |      
 |      Refer to `numpy.mean` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.mean : equivalent function
 |  
 |  min(...)
 |      a.min(axis=None, out=None, keepdims=False)
 |      
 |      Return the minimum along a given axis.
 |      
 |      Refer to `numpy.amin` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.amin : equivalent function
 |  
 |  newbyteorder(...)
 |      arr.newbyteorder(new_order='S')
 |      
 |      Return the array with the same data viewed with a different byte order.
 |      
 |      Equivalent to::
 |      
 |          arr.view(arr.dtype.newbytorder(new_order))
 |      
 |      Changes are also made in all fields and sub-arrays of the array data
 |      type.
 |      
 |      
 |      
 |      Parameters
 |      ----------
 |      new_order : string, optional
 |          Byte order to force; a value from the byte order specifications
 |          below. `new_order` codes can be any of:
 |      
 |          * 'S' - swap dtype from current to opposite endian
 |          * {'<', 'L'} - little endian
 |          * {'>', 'B'} - big endian
 |          * {'=', 'N'} - native order
 |          * {'|', 'I'} - ignore (no change to byte order)
 |      
 |          The default value ('S') results in swapping the current
 |          byte order. The code does a case-insensitive check on the first
 |          letter of `new_order` for the alternatives above.  For example,
 |          any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 |      
 |      
 |      Returns
 |      -------
 |      new_arr : array
 |          New array object with the dtype reflecting given change to the
 |          byte order.
 |  
 |  nonzero(...)
 |      a.nonzero()
 |      
 |      Return the indices of the elements that are non-zero.
 |      
 |      Refer to `numpy.nonzero` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.nonzero : equivalent function
 |  
 |  partition(...)
 |      a.partition(kth, axis=-1, kind='introselect', order=None)
 |      
 |      Rearranges the elements in the array in such a way that value of the
 |      element in kth position is in the position it would be in a sorted array.
 |      All elements smaller than the kth element are moved before this element and
 |      all equal or greater are moved behind it. The ordering of the elements in
 |      the two partitions is undefined.
 |      
 |      .. versionadded:: 1.8.0
 |      
 |      Parameters
 |      ----------
 |      kth : int or sequence of ints
 |          Element index to partition by. The kth element value will be in its
 |          final sorted position and all smaller elements will be moved before it
 |          and all equal or greater elements behind it.
 |          The order all elements in the partitions is undefined.
 |          If provided with a sequence of kth it will partition all elements
 |          indexed by kth of them into their sorted position at once.
 |      axis : int, optional
 |          Axis along which to sort. Default is -1, which means sort along the
 |          last axis.
 |      kind : {'introselect'}, optional
 |          Selection algorithm. Default is 'introselect'.
 |      order : str or list of str, optional
 |          When `a` is an array with fields defined, this argument specifies
 |          which fields to compare first, second, etc.  A single field can
 |          be specified as a string, and not all fields need be specified,
 |          but unspecified fields will still be used, in the order in which
 |          they come up in the dtype, to break ties.
 |      
 |      See Also
 |      --------
 |      numpy.partition : Return a parititioned copy of an array.
 |      argpartition : Indirect partition.
 |      sort : Full sort.
 |      
 |      Notes
 |      -----
 |      See ``np.partition`` for notes on the different algorithms.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([3, 4, 2, 1])
 |      >>> a.partition(3)
 |      >>> a
 |      array([2, 1, 3, 4])
 |      
 |      >>> a.partition((1, 3))
 |      array([1, 2, 3, 4])
 |  
 |  prod(...)
 |      a.prod(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Return the product of the array elements over the given axis
 |      
 |      Refer to `numpy.prod` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.prod : equivalent function
 |  
 |  ptp(...)
 |      a.ptp(axis=None, out=None)
 |      
 |      Peak to peak (maximum - minimum) value along a given axis.
 |      
 |      Refer to `numpy.ptp` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.ptp : equivalent function
 |  
 |  put(...)
 |      a.put(indices, values, mode='raise')
 |      
 |      Set ``a.flat[n] = values[n]`` for all `n` in indices.
 |      
 |      Refer to `numpy.put` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.put : equivalent function
 |  
 |  ravel(...)
 |      a.ravel([order])
 |      
 |      Return a flattened array.
 |      
 |      Refer to `numpy.ravel` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.ravel : equivalent function
 |      
 |      ndarray.flat : a flat iterator on the array.
 |  
 |  repeat(...)
 |      a.repeat(repeats, axis=None)
 |      
 |      Repeat elements of an array.
 |      
 |      Refer to `numpy.repeat` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.repeat : equivalent function
 |  
 |  reshape(...)
 |      a.reshape(shape, order='C')
 |      
 |      Returns an array containing the same data with a new shape.
 |      
 |      Refer to `numpy.reshape` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.reshape : equivalent function
 |      
 |      Notes
 |      -----
 |      Unlike the free function `numpy.reshape`, this method on `ndarray` allows
 |      the elements of the shape parameter to be passed in as separate arguments.
 |      For example, ``a.reshape(10, 11)`` is equivalent to
 |      ``a.reshape((10, 11))``.
 |  
 |  resize(...)
 |      a.resize(new_shape, refcheck=True)
 |      
 |      Change shape and size of array in-place.
 |      
 |      Parameters
 |      ----------
 |      new_shape : tuple of ints, or `n` ints
 |          Shape of resized array.
 |      refcheck : bool, optional
 |          If False, reference count will not be checked. Default is True.
 |      
 |      Returns
 |      -------
 |      None
 |      
 |      Raises
 |      ------
 |      ValueError
 |          If `a` does not own its own data or references or views to it exist,
 |          and the data memory must be changed.
 |          PyPy only: will always raise if the data memory must be changed, since
 |          there is no reliable way to determine if references or views to it
 |          exist.
 |      
 |      SystemError
 |          If the `order` keyword argument is specified. This behaviour is a
 |          bug in NumPy.
 |      
 |      See Also
 |      --------
 |      resize : Return a new array with the specified shape.
 |      
 |      Notes
 |      -----
 |      This reallocates space for the data area if necessary.
 |      
 |      Only contiguous arrays (data elements consecutive in memory) can be
 |      resized.
 |      
 |      The purpose of the reference count check is to make sure you
 |      do not use this array as a buffer for another Python object and then
 |      reallocate the memory. However, reference counts can increase in
 |      other ways so if you are sure that you have not shared the memory
 |      for this array with another Python object, then you may safely set
 |      `refcheck` to False.
 |      
 |      Examples
 |      --------
 |      Shrinking an array: array is flattened (in the order that the data are
 |      stored in memory), resized, and reshaped:
 |      
 |      >>> a = np.array([[0, 1], [2, 3]], order='C')
 |      >>> a.resize((2, 1))
 |      >>> a
 |      array([[0],
 |             [1]])
 |      
 |      >>> a = np.array([[0, 1], [2, 3]], order='F')
 |      >>> a.resize((2, 1))
 |      >>> a
 |      array([[0],
 |             [2]])
 |      
 |      Enlarging an array: as above, but missing entries are filled with zeros:
 |      
 |      >>> b = np.array([[0, 1], [2, 3]])
 |      >>> b.resize(2, 3) # new_shape parameter doesn't have to be a tuple
 |      >>> b
 |      array([[0, 1, 2],
 |             [3, 0, 0]])
 |      
 |      Referencing an array prevents resizing...
 |      
 |      >>> c = a
 |      >>> a.resize((1, 1))
 |      Traceback (most recent call last):
 |      ...
 |      ValueError: cannot resize an array that has been referenced ...
 |      
 |      Unless `refcheck` is False:
 |      
 |      >>> a.resize((1, 1), refcheck=False)
 |      >>> a
 |      array([[0]])
 |      >>> c
 |      array([[0]])
 |  
 |  round(...)
 |      a.round(decimals=0, out=None)
 |      
 |      Return `a` with each element rounded to the given number of decimals.
 |      
 |      Refer to `numpy.around` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.around : equivalent function
 |  
 |  searchsorted(...)
 |      a.searchsorted(v, side='left', sorter=None)
 |      
 |      Find indices where elements of v should be inserted in a to maintain order.
 |      
 |      For full documentation, see `numpy.searchsorted`
 |      
 |      See Also
 |      --------
 |      numpy.searchsorted : equivalent function
 |  
 |  setfield(...)
 |      a.setfield(val, dtype, offset=0)
 |      
 |      Put a value into a specified place in a field defined by a data-type.
 |      
 |      Place `val` into `a`'s field defined by `dtype` and beginning `offset`
 |      bytes into the field.
 |      
 |      Parameters
 |      ----------
 |      val : object
 |          Value to be placed in field.
 |      dtype : dtype object
 |          Data-type of the field in which to place `val`.
 |      offset : int, optional
 |          The number of bytes into the field at which to place `val`.
 |      
 |      Returns
 |      -------
 |      None
 |      
 |      See Also
 |      --------
 |      getfield
 |      
 |      Examples
 |      --------
 |      >>> x = np.eye(3)
 |      >>> x.getfield(np.float64)
 |      array([[ 1.,  0.,  0.],
 |             [ 0.,  1.,  0.],
 |             [ 0.,  0.,  1.]])
 |      >>> x.setfield(3, np.int32)
 |      >>> x.getfield(np.int32)
 |      array([[3, 3, 3],
 |             [3, 3, 3],
 |             [3, 3, 3]])
 |      >>> x
 |      array([[  1.00000000e+000,   1.48219694e-323,   1.48219694e-323],
 |             [  1.48219694e-323,   1.00000000e+000,   1.48219694e-323],
 |             [  1.48219694e-323,   1.48219694e-323,   1.00000000e+000]])
 |      >>> x.setfield(np.eye(3), np.int32)
 |      >>> x
 |      array([[ 1.,  0.,  0.],
 |             [ 0.,  1.,  0.],
 |             [ 0.,  0.,  1.]])
 |  
 |  setflags(...)
 |      a.setflags(write=None, align=None, uic=None)
 |      
 |      Set array flags WRITEABLE, ALIGNED, (WRITEBACKIFCOPY and UPDATEIFCOPY),
 |      respectively.
 |      
 |      These Boolean-valued flags affect how numpy interprets the memory
 |      area used by `a` (see Notes below). The ALIGNED flag can only
 |      be set to True if the data is actually aligned according to the type.
 |      The WRITEBACKIFCOPY and (deprecated) UPDATEIFCOPY flags can never be set
 |      to True. The flag WRITEABLE can only be set to True if the array owns its
 |      own memory, or the ultimate owner of the memory exposes a writeable buffer
 |      interface, or is a string. (The exception for string is made so that
 |      unpickling can be done without copying memory.)
 |      
 |      Parameters
 |      ----------
 |      write : bool, optional
 |          Describes whether or not `a` can be written to.
 |      align : bool, optional
 |          Describes whether or not `a` is aligned properly for its type.
 |      uic : bool, optional
 |          Describes whether or not `a` is a copy of another ""base"" array.
 |      
 |      Notes
 |      -----
 |      Array flags provide information about how the memory area used
 |      for the array is to be interpreted. There are 7 Boolean flags
 |      in use, only four of which can be changed by the user:
 |      WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED.
 |      
 |      WRITEABLE (W) the data area can be written to;
 |      
 |      ALIGNED (A) the data and strides are aligned appropriately for the hardware
 |      (as determined by the compiler);
 |      
 |      UPDATEIFCOPY (U) (deprecated), replaced by WRITEBACKIFCOPY;
 |      
 |      WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced
 |      by .base). When the C-API function PyArray_ResolveWritebackIfCopy is
 |      called, the base array will be updated with the contents of this array.
 |      
 |      All flags can be accessed using the single (upper case) letter as well
 |      as the full name.
 |      
 |      Examples
 |      --------
 |      >>> y
 |      array([[3, 1, 7],
 |             [2, 0, 0],
 |             [8, 5, 9]])
 |      >>> y.flags
 |        C_CONTIGUOUS : True
 |        F_CONTIGUOUS : False
 |        OWNDATA : True
 |        WRITEABLE : True
 |        ALIGNED : True
 |        WRITEBACKIFCOPY : False
 |        UPDATEIFCOPY : False
 |      >>> y.setflags(write=0, align=0)
 |      >>> y.flags
 |        C_CONTIGUOUS : True
 |        F_CONTIGUOUS : False
 |        OWNDATA : True
 |        WRITEABLE : False
 |        ALIGNED : False
 |        WRITEBACKIFCOPY : False
 |        UPDATEIFCOPY : False
 |      >>> y.setflags(uic=1)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: cannot set WRITEBACKIFCOPY flag to True
 |  
 |  sort(...)
 |      a.sort(axis=-1, kind='quicksort', order=None)
 |      
 |      Sort an array, in-place.
 |      
 |      Parameters
 |      ----------
 |      axis : int, optional
 |          Axis along which to sort. Default is -1, which means sort along the
 |          last axis.
 |      kind : {'quicksort', 'mergesort', 'heapsort'}, optional
 |          Sorting algorithm. Default is 'quicksort'.
 |      order : str or list of str, optional
 |          When `a` is an array with fields defined, this argument specifies
 |          which fields to compare first, second, etc.  A single field can
 |          be specified as a string, and not all fields need be specified,
 |          but unspecified fields will still be used, in the order in which
 |          they come up in the dtype, to break ties.
 |      
 |      See Also
 |      --------
 |      numpy.sort : Return a sorted copy of an array.
 |      argsort : Indirect sort.
 |      lexsort : Indirect stable sort on multiple keys.
 |      searchsorted : Find elements in sorted array.
 |      partition: Partial sort.
 |      
 |      Notes
 |      -----
 |      See ``sort`` for notes on the different sorting algorithms.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1,4], [3,1]])
 |      >>> a.sort(axis=1)
 |      >>> a
 |      array([[1, 4],
 |             [1, 3]])
 |      >>> a.sort(axis=0)
 |      >>> a
 |      array([[1, 3],
 |             [1, 4]])
 |      
 |      Use the `order` keyword to specify a field to use when sorting a
 |      structured array:
 |      
 |      >>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])
 |      >>> a.sort(order='y')
 |      >>> a
 |      array([('c', 1), ('a', 2)],
 |            dtype=[('x', '|S1'), ('y', '<i4')])
 |  
 |  squeeze(...)
 |      a.squeeze(axis=None)
 |      
 |      Remove single-dimensional entries from the shape of `a`.
 |      
 |      Refer to `numpy.squeeze` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.squeeze : equivalent function
 |  
 |  std(...)
 |      a.std(axis=None, dtype=None, out=None, ddof=0, keepdims=False)
 |      
 |      Returns the standard deviation of the array elements along given axis.
 |      
 |      Refer to `numpy.std` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.std : equivalent function
 |  
 |  sum(...)
 |      a.sum(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Return the sum of the array elements over the given axis.
 |      
 |      Refer to `numpy.sum` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.sum : equivalent function
 |  
 |  swapaxes(...)
 |      a.swapaxes(axis1, axis2)
 |      
 |      Return a view of the array with `axis1` and `axis2` interchanged.
 |      
 |      Refer to `numpy.swapaxes` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.swapaxes : equivalent function
 |  
 |  take(...)
 |      a.take(indices, axis=None, out=None, mode='raise')
 |      
 |      Return an array formed from the elements of `a` at the given indices.
 |      
 |      Refer to `numpy.take` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.take : equivalent function
 |  
 |  tobytes(...)
 |      a.tobytes(order='C')
 |      
 |      Construct Python bytes containing the raw data bytes in the array.
 |      
 |      Constructs Python bytes showing a copy of the raw contents of
 |      data memory. The bytes object can be produced in either 'C' or 'Fortran',
 |      or 'Any' order (the default is 'C'-order). 'Any' order means C-order
 |      unless the F_CONTIGUOUS flag in the array is set, in which case it
 |      means 'Fortran' order.
 |      
 |      .. versionadded:: 1.9.0
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', None}, optional
 |          Order of the data for multidimensional arrays:
 |          C, Fortran, or the same as for the original array.
 |      
 |      Returns
 |      -------
 |      s : bytes
 |          Python bytes exhibiting a copy of `a`'s raw data.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[0, 1], [2, 3]])
 |      >>> x.tobytes()
 |      b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
 |      >>> x.tobytes('C') == x.tobytes()
 |      True
 |      >>> x.tobytes('F')
 |      b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
 |  
 |  tofile(...)
 |      a.tofile(fid, sep="""", format=""%s"")
 |      
 |      Write array to a file as text or binary (default).
 |      
 |      Data is always written in 'C' order, independent of the order of `a`.
 |      The data produced by this method can be recovered using the function
 |      fromfile().
 |      
 |      Parameters
 |      ----------
 |      fid : file or str
 |          An open file object, or a string containing a filename.
 |      sep : str
 |          Separator between array items for text output.
 |          If """" (empty), a binary file is written, equivalent to
 |          ``file.write(a.tobytes())``.
 |      format : str
 |          Format string for text file output.
 |          Each entry in the array is formatted to text by first converting
 |          it to the closest Python type, and then using ""format"" % item.
 |      
 |      Notes
 |      -----
 |      This is a convenience function for quick storage of array data.
 |      Information on endianness and precision is lost, so this method is not a
 |      good choice for files intended to archive data or transport data between
 |      machines with different endianness. Some of these problems can be overcome
 |      by outputting the data as text files, at the expense of speed and file
 |      size.
 |  
 |  tolist(...)
 |      a.tolist()
 |      
 |      Return the array as a (possibly nested) list.
 |      
 |      Return a copy of the array data as a (nested) Python list.
 |      Data items are converted to the nearest compatible Python type.
 |      
 |      Parameters
 |      ----------
 |      none
 |      
 |      Returns
 |      -------
 |      y : list
 |          The possibly nested list of array elements.
 |      
 |      Notes
 |      -----
 |      The array may be recreated, ``a = np.array(a.tolist())``.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([1, 2])
 |      >>> a.tolist()
 |      [1, 2]
 |      >>> a = np.array([[1, 2], [3, 4]])
 |      >>> list(a)
 |      [array([1, 2]), array([3, 4])]
 |      >>> a.tolist()
 |      [[1, 2], [3, 4]]
 |  
 |  tostring(...)
 |      a.tostring(order='C')
 |      
 |      Construct Python bytes containing the raw data bytes in the array.
 |      
 |      Constructs Python bytes showing a copy of the raw contents of
 |      data memory. The bytes object can be produced in either 'C' or 'Fortran',
 |      or 'Any' order (the default is 'C'-order). 'Any' order means C-order
 |      unless the F_CONTIGUOUS flag in the array is set, in which case it
 |      means 'Fortran' order.
 |      
 |      This function is a compatibility alias for tobytes. Despite its name it returns bytes not strings.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', None}, optional
 |          Order of the data for multidimensional arrays:
 |          C, Fortran, or the same as for the original array.
 |      
 |      Returns
 |      -------
 |      s : bytes
 |          Python bytes exhibiting a copy of `a`'s raw data.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[0, 1], [2, 3]])
 |      >>> x.tobytes()
 |      b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
 |      >>> x.tobytes('C') == x.tobytes()
 |      True
 |      >>> x.tobytes('F')
 |      b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
 |  
 |  trace(...)
 |      a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)
 |      
 |      Return the sum along diagonals of the array.
 |      
 |      Refer to `numpy.trace` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.trace : equivalent function
 |  
 |  transpose(...)
 |      a.transpose(*axes)
 |      
 |      Returns a view of the array with axes transposed.
 |      
 |      For a 1-D array, this has no effect. (To change between column and
 |      row vectors, first cast the 1-D array into a matrix object.)
 |      For a 2-D array, this is the usual matrix transpose.
 |      For an n-D array, if axes are given, their order indicates how the
 |      axes are permuted (see Examples). If axes are not provided and
 |      ``a.shape = (i[0], i[1], ... i[n-2], i[n-1])``, then
 |      ``a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0])``.
 |      
 |      Parameters
 |      ----------
 |      axes : None, tuple of ints, or `n` ints
 |      
 |       * None or no argument: reverses the order of the axes.
 |      
 |       * tuple of ints: `i` in the `j`-th place in the tuple means `a`'s
 |         `i`-th axis becomes `a.transpose()`'s `j`-th axis.
 |      
 |       * `n` ints: same as an n-tuple of the same ints (this form is
 |         intended simply as a ""convenience"" alternative to the tuple form)
 |      
 |      Returns
 |      -------
 |      out : ndarray
 |          View of `a`, with axes suitably permuted.
 |      
 |      See Also
 |      --------
 |      ndarray.T : Array property returning the array transposed.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1, 2], [3, 4]])
 |      >>> a
 |      array([[1, 2],
 |             [3, 4]])
 |      >>> a.transpose()
 |      array([[1, 3],
 |             [2, 4]])
 |      >>> a.transpose((1, 0))
 |      array([[1, 3],
 |             [2, 4]])
 |      >>> a.transpose(1, 0)
 |      array([[1, 3],
 |             [2, 4]])
 |  
 |  var(...)
 |      a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False)
 |      
 |      Returns the variance of the array elements, along given axis.
 |      
 |      Refer to `numpy.var` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.var : equivalent function
 |  
 |  view(...)
 |      a.view(dtype=None, type=None)
 |      
 |      New view of array with the same data.
 |      
 |      Parameters
 |      ----------
 |      dtype : data-type or ndarray sub-class, optional
 |          Data-type descriptor of the returned view, e.g., float32 or int16. The
 |          default, None, results in the view having the same data-type as `a`.
 |          This argument can also be specified as an ndarray sub-class, which
 |          then specifies the type of the returned object (this is equivalent to
 |          setting the ``type`` parameter).
 |      type : Python type, optional
 |          Type of the returned view, e.g., ndarray or matrix.  Again, the
 |          default None results in type preservation.
 |      
 |      Notes
 |      -----
 |      ``a.view()`` is used two different ways:
 |      
 |      ``a.view(some_dtype)`` or ``a.view(dtype=some_dtype)`` constructs a view
 |      of the array's memory with a different data-type.  This can cause a
 |      reinterpretation of the bytes of memory.
 |      
 |      ``a.view(ndarray_subclass)`` or ``a.view(type=ndarray_subclass)`` just
 |      returns an instance of `ndarray_subclass` that looks at the same array
 |      (same shape, dtype, etc.)  This does not cause a reinterpretation of the
 |      memory.
 |      
 |      For ``a.view(some_dtype)``, if ``some_dtype`` has a different number of
 |      bytes per entry than the previous dtype (for example, converting a
 |      regular array to a structured array), then the behavior of the view
 |      cannot be predicted just from the superficial appearance of ``a`` (shown
 |      by ``print(a)``). It also depends on exactly how ``a`` is stored in
 |      memory. Therefore if ``a`` is C-ordered versus fortran-ordered, versus
 |      defined as a slice or transpose, etc., the view may give different
 |      results.
 |      
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])
 |      
 |      Viewing array data using a different type and dtype:
 |      
 |      >>> y = x.view(dtype=np.int16, type=np.matrix)
 |      >>> y
 |      matrix([[513]], dtype=int16)
 |      >>> print(type(y))
 |      <class 'numpy.matrixlib.defmatrix.matrix'>
 |      
 |      Creating a view on a structured array so it can be used in calculations
 |      
 |      >>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)])
 |      >>> xv = x.view(dtype=np.int8).reshape(-1,2)
 |      >>> xv
 |      array([[1, 2],
 |             [3, 4]], dtype=int8)
 |      >>> xv.mean(0)
 |      array([ 2.,  3.])
 |      
 |      Making changes to the view changes the underlying array
 |      
 |      >>> xv[0,1] = 20
 |      >>> print(x)
 |      [(1, 20) (3, 4)]
 |      
 |      Using a view to convert an array to a recarray:
 |      
 |      >>> z = x.view(np.recarray)
 |      >>> z.a
 |      array([1], dtype=int8)
 |      
 |      Views share data:
 |      
 |      >>> x[0] = (9, 10)
 |      >>> z[0]
 |      (9, 10)
 |      
 |      Views that change the dtype size (bytes per entry) should normally be
 |      avoided on arrays defined by slices, transposes, fortran-ordering, etc.:
 |      
 |      >>> x = np.array([[1,2,3],[4,5,6]], dtype=np.int16)
 |      >>> y = x[:, 0:2]
 |      >>> y
 |      array([[1, 2],
 |             [4, 5]], dtype=int16)
 |      >>> y.view(dtype=[('width', np.int16), ('length', np.int16)])
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: new type not compatible with array.
 |      >>> z = y.copy()
 |      >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
 |      array([[(1, 2)],
 |             [(4, 5)]], dtype=[('width', '<i2'), ('length', '<i2')])
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from numpy.ndarray:
 |  
 |  T
 |      Same as self.transpose(), except that self is returned if
 |      self.ndim < 2.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[1.,2.],[3.,4.]])
 |      >>> x
 |      array([[ 1.,  2.],
 |             [ 3.,  4.]])
 |      >>> x.T
 |      array([[ 1.,  3.],
 |             [ 2.,  4.]])
 |      >>> x = np.array([1.,2.,3.,4.])
 |      >>> x
 |      array([ 1.,  2.,  3.,  4.])
 |      >>> x.T
 |      array([ 1.,  2.,  3.,  4.])
 |  
 |  __array_interface__
 |      Array protocol: Python side.
 |  
 |  __array_priority__
 |      Array priority.
 |  
 |  __array_struct__
 |      Array protocol: C-struct side.
 |  
 |  base
 |      Base object if memory is from some other object.
 |      
 |      Examples
 |      --------
 |      The base of an array that owns its memory is None:
 |      
 |      >>> x = np.array([1,2,3,4])
 |      >>> x.base is None
 |      True
 |      
 |      Slicing creates a view, whose memory is shared with x:
 |      
 |      >>> y = x[2:]
 |      >>> y.base is x
 |      True
 |  
 |  ctypes
 |      An object to simplify the interaction of the array with the ctypes
 |      module.
 |      
 |      This attribute creates an object that makes it easier to use arrays
 |      when calling shared libraries with the ctypes module. The returned
 |      object has, among others, data, shape, and strides attributes (see
 |      Notes below) which themselves return ctypes objects that can be used
 |      as arguments to a shared library.
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      c : Python object
 |          Possessing attributes data, shape, strides, etc.
 |      
 |      See Also
 |      --------
 |      numpy.ctypeslib
 |      
 |      Notes
 |      -----
 |      Below are the public attributes of this object which were documented
 |      in ""Guide to NumPy"" (we have omitted undocumented public attributes,
 |      as well as documented private attributes):
 |      
 |      * data: A pointer to the memory area of the array as a Python integer.
 |        This memory area may contain data that is not aligned, or not in correct
 |        byte-order. The memory area may not even be writeable. The array
 |        flags and data-type of this array should be respected when passing this
 |        attribute to arbitrary C-code to avoid trouble that can include Python
 |        crashing. User Beware! The value of this attribute is exactly the same
 |        as self._array_interface_['data'][0].
 |      
 |      * shape (c_intp*self.ndim): A ctypes array of length self.ndim where
 |        the basetype is the C-integer corresponding to dtype('p') on this
 |        platform. This base-type could be c_int, c_long, or c_longlong
 |        depending on the platform. The c_intp type is defined accordingly in
 |        numpy.ctypeslib. The ctypes array contains the shape of the underlying
 |        array.
 |      
 |      * strides (c_intp*self.ndim): A ctypes array of length self.ndim where
 |        the basetype is the same as for the shape attribute. This ctypes array
 |        contains the strides information from the underlying array. This strides
 |        information is important for showing how many bytes must be jumped to
 |        get to the next element in the array.
 |      
 |      * data_as(obj): Return the data pointer cast to a particular c-types object.
 |        For example, calling self._as_parameter_ is equivalent to
 |        self.data_as(ctypes.c_void_p). Perhaps you want to use the data as a
 |        pointer to a ctypes array of floating-point data:
 |        self.data_as(ctypes.POINTER(ctypes.c_double)).
 |      
 |      * shape_as(obj): Return the shape tuple as an array of some other c-types
 |        type. For example: self.shape_as(ctypes.c_short).
 |      
 |      * strides_as(obj): Return the strides tuple as an array of some other
 |        c-types type. For example: self.strides_as(ctypes.c_longlong).
 |      
 |      Be careful using the ctypes attribute - especially on temporary
 |      arrays or arrays constructed on the fly. For example, calling
 |      ``(a+b).ctypes.data_as(ctypes.c_void_p)`` returns a pointer to memory
 |      that is invalid because the array created as (a+b) is deallocated
 |      before the next Python statement. You can avoid this problem using
 |      either ``c=a+b`` or ``ct=(a+b).ctypes``. In the latter case, ct will
 |      hold a reference to the array until ct is deleted or re-assigned.
 |      
 |      If the ctypes module is not available, then the ctypes attribute
 |      of array objects still returns something useful, but ctypes objects
 |      are not returned and errors may be raised instead. In particular,
 |      the object will still have the as parameter attribute which will
 |      return an integer equal to the data attribute.
 |      
 |      Examples
 |      --------
 |      >>> import ctypes
 |      >>> x
 |      array([[0, 1],
 |             [2, 3]])
 |      >>> x.ctypes.data
 |      30439712
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long))
 |      <ctypes.LP_c_long object at 0x01F01300>
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)).contents
 |      c_long(0)
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_longlong)).contents
 |      c_longlong(4294967296L)
 |      >>> x.ctypes.shape
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FFD580>
 |      >>> x.ctypes.shape_as(ctypes.c_long)
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
 |      >>> x.ctypes.strides
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
 |      >>> x.ctypes.strides_as(ctypes.c_longlong)
 |      <numpy.core._internal.c_longlong_Array_2 object at 0x01F01300>
 |  
 |  data
 |      Python buffer object pointing to the start of the array's data.
 |  
 |  dtype
 |      Data-type of the array's elements.
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      d : numpy dtype object
 |      
 |      See Also
 |      --------
 |      numpy.dtype
 |      
 |      Examples
 |      --------
 |      >>> x
 |      array([[0, 1],
 |             [2, 3]])
 |      >>> x.dtype
 |      dtype('int32')
 |      >>> type(x.dtype)
 |      <type 'numpy.dtype'>
 |  
 |  flags
 |      Information about the memory layout of the array.
 |      
 |      Attributes
 |      ----------
 |      C_CONTIGUOUS (C)
 |          The data is in a single, C-style contiguous segment.
 |      F_CONTIGUOUS (F)
 |          The data is in a single, Fortran-style contiguous segment.
 |      OWNDATA (O)
 |          The array owns the memory it uses or borrows it from another object.
 |      WRITEABLE (W)
 |          The data area can be written to.  Setting this to False locks
 |          the data, making it read-only.  A view (slice, etc.) inherits WRITEABLE
 |          from its base array at creation time, but a view of a writeable
 |          array may be subsequently locked while the base array remains writeable.
 |          (The opposite is not true, in that a view of a locked array may not
 |          be made writeable.  However, currently, locking a base object does not
 |          lock any views that already reference it, so under that circumstance it
 |          is possible to alter the contents of a locked array via a previously
 |          created writeable view onto it.)  Attempting to change a non-writeable
 |          array raises a RuntimeError exception.
 |      ALIGNED (A)
 |          The data and all elements are aligned appropriately for the hardware.
 |      WRITEBACKIFCOPY (X)
 |          This array is a copy of some other array. The C-API function
 |          PyArray_ResolveWritebackIfCopy must be called before deallocating
 |          to the base array will be updated with the contents of this array.
 |      UPDATEIFCOPY (U)
 |          (Deprecated, use WRITEBACKIFCOPY) This array is a copy of some other array.
 |          When this array is
 |          deallocated, the base array will be updated with the contents of
 |          this array.
 |      FNC
 |          F_CONTIGUOUS and not C_CONTIGUOUS.
 |      FORC
 |          F_CONTIGUOUS or C_CONTIGUOUS (one-segment test).
 |      BEHAVED (B)
 |          ALIGNED and WRITEABLE.
 |      CARRAY (CA)
 |          BEHAVED and C_CONTIGUOUS.
 |      FARRAY (FA)
 |          BEHAVED and F_CONTIGUOUS and not C_CONTIGUOUS.
 |      
 |      Notes
 |      -----
 |      The `flags` object can be accessed dictionary-like (as in ``a.flags['WRITEABLE']``),
 |      or by using lowercased attribute names (as in ``a.flags.writeable``). Short flag
 |      names are only supported in dictionary access.
 |      
 |      Only the WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED flags can be
 |      changed by the user, via direct assignment to the attribute or dictionary
 |      entry, or by calling `ndarray.setflags`.
 |      
 |      The array flags cannot be set arbitrarily:
 |      
 |      - UPDATEIFCOPY can only be set ``False``.
 |      - WRITEBACKIFCOPY can only be set ``False``.
 |      - ALIGNED can only be set ``True`` if the data is truly aligned.
 |      - WRITEABLE can only be set ``True`` if the array owns its own memory
 |        or the ultimate owner of the memory exposes a writeable buffer
 |        interface or is a string.
 |      
 |      Arrays can be both C-style and Fortran-style contiguous simultaneously.
 |      This is clear for 1-dimensional arrays, but can also be true for higher
 |      dimensional arrays.
 |      
 |      Even for contiguous arrays a stride for a given dimension
 |      ``arr.strides[dim]`` may be *arbitrary* if ``arr.shape[dim] == 1``
 |      or the array has no elements.
 |      It does *not* generally hold that ``self.strides[-1] == self.itemsize``
 |      for C-style contiguous arrays or ``self.strides[0] == self.itemsize`` for
 |      Fortran-style contiguous arrays is true.
 |  
 |  flat
 |      A 1-D iterator over the array.
 |      
 |      This is a `numpy.flatiter` instance, which acts similarly to, but is not
 |      a subclass of, Python's built-in iterator object.
 |      
 |      See Also
 |      --------
 |      flatten : Return a copy of the array collapsed into one dimension.
 |      
 |      flatiter
 |      
 |      Examples
 |      --------
 |      >>> x = np.arange(1, 7).reshape(2, 3)
 |      >>> x
 |      array([[1, 2, 3],
 |             [4, 5, 6]])
 |      >>> x.flat[3]
 |      4
 |      >>> x.T
 |      array([[1, 4],
 |             [2, 5],
 |             [3, 6]])
 |      >>> x.T.flat[3]
 |      5
 |      >>> type(x.flat)
 |      <type 'numpy.flatiter'>
 |      
 |      An assignment example:
 |      
 |      >>> x.flat = 3; x
 |      array([[3, 3, 3],
 |             [3, 3, 3]])
 |      >>> x.flat[[1,4]] = 1; x
 |      array([[3, 1, 3],
 |             [3, 1, 3]])
 |  
 |  imag
 |      The imaginary part of the array.
 |      
 |      Examples
 |      --------
 |      >>> x = np.sqrt([1+0j, 0+1j])
 |      >>> x.imag
 |      array([ 0.        ,  0.70710678])
 |      >>> x.imag.dtype
 |      dtype('float64')
 |  
 |  itemsize
 |      Length of one array element in bytes.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1,2,3], dtype=np.float64)
 |      >>> x.itemsize
 |      8
 |      >>> x = np.array([1,2,3], dtype=np.complex128)
 |      >>> x.itemsize
 |      16
 |  
 |  nbytes
 |      Total bytes consumed by the elements of the array.
 |      
 |      Notes
 |      -----
 |      Does not include memory consumed by non-element attributes of the
 |      array object.
 |      
 |      Examples
 |      --------
 |      >>> x = np.zeros((3,5,2), dtype=np.complex128)
 |      >>> x.nbytes
 |      480
 |      >>> np.prod(x.shape) * x.itemsize
 |      480
 |  
 |  ndim
 |      Number of array dimensions.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 3])
 |      >>> x.ndim
 |      1
 |      >>> y = np.zeros((2, 3, 4))
 |      >>> y.ndim
 |      3
 |  
 |  real
 |      The real part of the array.
 |      
 |      Examples
 |      --------
 |      >>> x = np.sqrt([1+0j, 0+1j])
 |      >>> x.real
 |      array([ 1.        ,  0.70710678])
 |      >>> x.real.dtype
 |      dtype('float64')
 |      
 |      See Also
 |      --------
 |      numpy.real : equivalent function
 |  
 |  shape
 |      Tuple of array dimensions.
 |      
 |      The shape property is usually used to get the current shape of an array,
 |      but may also be used to reshape the array in-place by assigning a tuple of
 |      array dimensions to it.  As with `numpy.reshape`, one of the new shape
 |      dimensions can be -1, in which case its value is inferred from the size of
 |      the array and the remaining dimensions. Reshaping an array in-place will
 |      fail if a copy is required.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 3, 4])
 |      >>> x.shape
 |      (4,)
 |      >>> y = np.zeros((2, 3, 4))
 |      >>> y.shape
 |      (2, 3, 4)
 |      >>> y.shape = (3, 8)
 |      >>> y
 |      array([[ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
 |             [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
 |             [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.]])
 |      >>> y.shape = (3, 6)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: total size of new array must be unchanged
 |      >>> np.zeros((4,2))[::2].shape = (-1,)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      AttributeError: incompatible shape for a non-contiguous array
 |      
 |      See Also
 |      --------
 |      numpy.reshape : similar function
 |      ndarray.reshape : similar method
 |  
 |  size
 |      Number of elements in the array.
 |      
 |      Equivalent to ``np.prod(a.shape)``, i.e., the product of the array's
 |      dimensions.
 |      
 |      Examples
 |      --------
 |      >>> x = np.zeros((3, 5, 2), dtype=np.complex128)
 |      >>> x.size
 |      30
 |      >>> np.prod(x.shape)
 |      30
 |  
 |  strides
 |      Tuple of bytes to step in each dimension when traversing an array.
 |      
 |      The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a`
 |      is::
 |      
 |          offset = sum(np.array(i) * a.strides)
 |      
 |      A more detailed explanation of strides can be found in the
 |      ""ndarray.rst"" file in the NumPy reference guide.
 |      
 |      Notes
 |      -----
 |      Imagine an array of 32-bit integers (each 4 bytes)::
 |      
 |        x = np.array([[0, 1, 2, 3, 4],
 |                      [5, 6, 7, 8, 9]], dtype=np.int32)
 |      
 |      This array is stored in memory as 40 bytes, one after the other
 |      (known as a contiguous block of memory).  The strides of an array tell
 |      us how many bytes we have to skip in memory to move to the next position
 |      along a certain axis.  For example, we have to skip 4 bytes (1 value) to
 |      move to the next column, but 20 bytes (5 values) to get to the same
 |      position in the next row.  As such, the strides for the array `x` will be
 |      ``(20, 4)``.
 |      
 |      See Also
 |      --------
 |      numpy.lib.stride_tricks.as_strided
 |      
 |      Examples
 |      --------
 |      >>> y = np.reshape(np.arange(2*3*4), (2,3,4))
 |      >>> y
 |      array([[[ 0,  1,  2,  3],
 |              [ 4,  5,  6,  7],
 |              [ 8,  9, 10, 11]],
 |             [[12, 13, 14, 15],
 |              [16, 17, 18, 19],
 |              [20, 21, 22, 23]]])
 |      >>> y.strides
 |      (48, 16, 4)
 |      >>> y[1,1,1]
 |      17
 |      >>> offset=sum(y.strides * np.array((1,1,1)))
 |      >>> offset/y.itemsize
 |      17
 |      
 |      >>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0)
 |      >>> x.strides
 |      (32, 4, 224, 1344)
 |      >>> i = np.array([3,5,2,2])
 |      >>> offset = sum(i * x.strides)
 |      >>> x[3,5,2,2]
 |      813
 |      >>> offset / x.itemsize
 |      813
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from numpy.ndarray:
 |  
 |  __hash__ = None
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.matlab.mio5_params.MatlabObject,io.matlab.mio5_params,MatlabObject,"Python Library Documentation: class MatlabObject in module scipy.io.matlab.mio5_params

class MatlabObject(numpy.ndarray)
 |  ndarray Subclass to contain matlab object
 |  
 |  Method resolution order:
 |      MatlabObject
 |      numpy.ndarray
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __array_finalize__(self, obj)
 |      None.
 |  
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |  
 |  __new__(cls, input_array, classname=None)
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from numpy.ndarray:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __array__(...)
 |      a.__array__(|dtype) -> reference if type unchanged, copy otherwise.
 |      
 |      Returns either a new reference to self if dtype is not given or a new array
 |      of provided data type if dtype is different from the current dtype of the
 |      array.
 |  
 |  __array_prepare__(...)
 |      a.__array_prepare__(obj) -> Object of same type as ndarray object obj.
 |  
 |  __array_ufunc__(...)
 |  
 |  __array_wrap__(...)
 |      a.__array_wrap__(obj) -> Object of same type as ndarray object a.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __complex__(...)
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __copy__(...)
 |      a.__copy__()
 |      
 |      Used if :func:`copy.copy` is called on an array. Returns a copy of the array.
 |      
 |      Equivalent to ``a.copy(order='K')``.
 |  
 |  __deepcopy__(...)
 |      a.__deepcopy__(memo, /) -> Deep copy of array.
 |      
 |      Used if :func:`copy.deepcopy` is called on an array.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __format__(...)
 |      default object formatter
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iadd__(self, value, /)
 |      Return self+=value.
 |  
 |  __iand__(self, value, /)
 |      Return self&=value.
 |  
 |  __ifloordiv__(self, value, /)
 |      Return self//=value.
 |  
 |  __ilshift__(self, value, /)
 |      Return self<<=value.
 |  
 |  __imatmul__(self, value, /)
 |      Return self@=value.
 |  
 |  __imod__(self, value, /)
 |      Return self%=value.
 |  
 |  __imul__(self, value, /)
 |      Return self*=value.
 |  
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __ior__(self, value, /)
 |      Return self|=value.
 |  
 |  __ipow__(self, value, /)
 |      Return self**=value.
 |  
 |  __irshift__(self, value, /)
 |      Return self>>=value.
 |  
 |  __isub__(self, value, /)
 |      Return self-=value.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __itruediv__(self, value, /)
 |      Return self/=value.
 |  
 |  __ixor__(self, value, /)
 |      Return self^=value.
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __matmul__(self, value, /)
 |      Return self@value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __reduce__(...)
 |      a.__reduce__()
 |      
 |      For pickling.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmatmul__(self, value, /)
 |      Return value@self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __setstate__(...)
 |      a.__setstate__(state, /)
 |      
 |      For unpickling.
 |      
 |      The `state` argument must be a sequence that contains the following
 |      elements:
 |      
 |      Parameters
 |      ----------
 |      version : int
 |          optional pickle version. If omitted defaults to 0.
 |      shape : tuple
 |      dtype : data-type
 |      isFortran : bool
 |      rawdata : string or list
 |          a binary string with the data (or a list if 'a' is an object array)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  all(...)
 |      a.all(axis=None, out=None, keepdims=False)
 |      
 |      Returns True if all elements evaluate to True.
 |      
 |      Refer to `numpy.all` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.all : equivalent function
 |  
 |  any(...)
 |      a.any(axis=None, out=None, keepdims=False)
 |      
 |      Returns True if any of the elements of `a` evaluate to True.
 |      
 |      Refer to `numpy.any` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.any : equivalent function
 |  
 |  argmax(...)
 |      a.argmax(axis=None, out=None)
 |      
 |      Return indices of the maximum values along the given axis.
 |      
 |      Refer to `numpy.argmax` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argmax : equivalent function
 |  
 |  argmin(...)
 |      a.argmin(axis=None, out=None)
 |      
 |      Return indices of the minimum values along the given axis of `a`.
 |      
 |      Refer to `numpy.argmin` for detailed documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argmin : equivalent function
 |  
 |  argpartition(...)
 |      a.argpartition(kth, axis=-1, kind='introselect', order=None)
 |      
 |      Returns the indices that would partition this array.
 |      
 |      Refer to `numpy.argpartition` for full documentation.
 |      
 |      .. versionadded:: 1.8.0
 |      
 |      See Also
 |      --------
 |      numpy.argpartition : equivalent function
 |  
 |  argsort(...)
 |      a.argsort(axis=-1, kind='quicksort', order=None)
 |      
 |      Returns the indices that would sort this array.
 |      
 |      Refer to `numpy.argsort` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argsort : equivalent function
 |  
 |  astype(...)
 |      a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)
 |      
 |      Copy of the array, cast to a specified type.
 |      
 |      Parameters
 |      ----------
 |      dtype : str or dtype
 |          Typecode or data-type to which the array is cast.
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          Controls the memory layout order of the result.
 |          'C' means C order, 'F' means Fortran order, 'A'
 |          means 'F' order if all the arrays are Fortran contiguous,
 |          'C' order otherwise, and 'K' means as close to the
 |          order the array elements appear in memory as possible.
 |          Default is 'K'.
 |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
 |          Controls what kind of data casting may occur. Defaults to 'unsafe'
 |          for backwards compatibility.
 |      
 |            * 'no' means the data types should not be cast at all.
 |            * 'equiv' means only byte-order changes are allowed.
 |            * 'safe' means only casts which can preserve values are allowed.
 |            * 'same_kind' means only safe casts or casts within a kind,
 |              like float64 to float32, are allowed.
 |            * 'unsafe' means any data conversions may be done.
 |      subok : bool, optional
 |          If True, then sub-classes will be passed-through (default), otherwise
 |          the returned array will be forced to be a base-class array.
 |      copy : bool, optional
 |          By default, astype always returns a newly allocated array. If this
 |          is set to false, and the `dtype`, `order`, and `subok`
 |          requirements are satisfied, the input array is returned instead
 |          of a copy.
 |      
 |      Returns
 |      -------
 |      arr_t : ndarray
 |          Unless `copy` is False and the other conditions for returning the input
 |          array are satisfied (see description for `copy` input parameter), `arr_t`
 |          is a new array of the same shape as the input array, with dtype, order
 |          given by `dtype`, `order`.
 |      
 |      Notes
 |      -----
 |      Starting in NumPy 1.9, astype method now returns an error if the string
 |      dtype to cast to is not long enough in 'safe' casting mode to hold the max
 |      value of integer/float array that is being casted. Previously the casting
 |      was allowed even if the result was truncated.
 |      
 |      Raises
 |      ------
 |      ComplexWarning
 |          When casting from complex to float or int. To avoid this,
 |          one should use ``a.real.astype(t)``.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 2.5])
 |      >>> x
 |      array([ 1. ,  2. ,  2.5])
 |      
 |      >>> x.astype(int)
 |      array([1, 2, 2])
 |  
 |  byteswap(...)
 |      a.byteswap(inplace=False)
 |      
 |      Swap the bytes of the array elements
 |      
 |      Toggle between low-endian and big-endian data representation by
 |      returning a byteswapped array, optionally swapped in-place.
 |      
 |      Parameters
 |      ----------
 |      inplace : bool, optional
 |          If ``True``, swap bytes in-place, default is ``False``.
 |      
 |      Returns
 |      -------
 |      out : ndarray
 |          The byteswapped array. If `inplace` is ``True``, this is
 |          a view to self.
 |      
 |      Examples
 |      --------
 |      >>> A = np.array([1, 256, 8755], dtype=np.int16)
 |      >>> map(hex, A)
 |      ['0x1', '0x100', '0x2233']
 |      >>> A.byteswap(inplace=True)
 |      array([  256,     1, 13090], dtype=int16)
 |      >>> map(hex, A)
 |      ['0x100', '0x1', '0x3322']
 |      
 |      Arrays of strings are not swapped
 |      
 |      >>> A = np.array(['ceg', 'fac'])
 |      >>> A.byteswap()
 |      array(['ceg', 'fac'],
 |            dtype='|S3')
 |  
 |  choose(...)
 |      a.choose(choices, out=None, mode='raise')
 |      
 |      Use an index array to construct a new array from a set of choices.
 |      
 |      Refer to `numpy.choose` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.choose : equivalent function
 |  
 |  clip(...)
 |      a.clip(min=None, max=None, out=None)
 |      
 |      Return an array whose values are limited to ``[min, max]``.
 |      One of max or min must be given.
 |      
 |      Refer to `numpy.clip` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.clip : equivalent function
 |  
 |  compress(...)
 |      a.compress(condition, axis=None, out=None)
 |      
 |      Return selected slices of this array along given axis.
 |      
 |      Refer to `numpy.compress` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.compress : equivalent function
 |  
 |  conj(...)
 |      a.conj()
 |      
 |      Complex-conjugate all elements.
 |      
 |      Refer to `numpy.conjugate` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.conjugate : equivalent function
 |  
 |  conjugate(...)
 |      a.conjugate()
 |      
 |      Return the complex conjugate, element-wise.
 |      
 |      Refer to `numpy.conjugate` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.conjugate : equivalent function
 |  
 |  copy(...)
 |      a.copy(order='C')
 |      
 |      Return a copy of the array.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          Controls the memory layout of the copy. 'C' means C-order,
 |          'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
 |          'C' otherwise. 'K' means match the layout of `a` as closely
 |          as possible. (Note that this function and :func:`numpy.copy` are very
 |          similar, but have different default values for their order=
 |          arguments.)
 |      
 |      See also
 |      --------
 |      numpy.copy
 |      numpy.copyto
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[1,2,3],[4,5,6]], order='F')
 |      
 |      >>> y = x.copy()
 |      
 |      >>> x.fill(0)
 |      
 |      >>> x
 |      array([[0, 0, 0],
 |             [0, 0, 0]])
 |      
 |      >>> y
 |      array([[1, 2, 3],
 |             [4, 5, 6]])
 |      
 |      >>> y.flags['C_CONTIGUOUS']
 |      True
 |  
 |  cumprod(...)
 |      a.cumprod(axis=None, dtype=None, out=None)
 |      
 |      Return the cumulative product of the elements along the given axis.
 |      
 |      Refer to `numpy.cumprod` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.cumprod : equivalent function
 |  
 |  cumsum(...)
 |      a.cumsum(axis=None, dtype=None, out=None)
 |      
 |      Return the cumulative sum of the elements along the given axis.
 |      
 |      Refer to `numpy.cumsum` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.cumsum : equivalent function
 |  
 |  diagonal(...)
 |      a.diagonal(offset=0, axis1=0, axis2=1)
 |      
 |      Return specified diagonals. In NumPy 1.9 the returned array is a
 |      read-only view instead of a copy as in previous NumPy versions.  In
 |      a future version the read-only restriction will be removed.
 |      
 |      Refer to :func:`numpy.diagonal` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.diagonal : equivalent function
 |  
 |  dot(...)
 |      a.dot(b, out=None)
 |      
 |      Dot product of two arrays.
 |      
 |      Refer to `numpy.dot` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.dot : equivalent function
 |      
 |      Examples
 |      --------
 |      >>> a = np.eye(2)
 |      >>> b = np.ones((2, 2)) * 2
 |      >>> a.dot(b)
 |      array([[ 2.,  2.],
 |             [ 2.,  2.]])
 |      
 |      This array method can be conveniently chained:
 |      
 |      >>> a.dot(b).dot(b)
 |      array([[ 8.,  8.],
 |             [ 8.,  8.]])
 |  
 |  dump(...)
 |      a.dump(file)
 |      
 |      Dump a pickle of the array to the specified file.
 |      The array can be read back with pickle.load or numpy.load.
 |      
 |      Parameters
 |      ----------
 |      file : str
 |          A string naming the dump file.
 |  
 |  dumps(...)
 |      a.dumps()
 |      
 |      Returns the pickle of the array as a string.
 |      pickle.loads or numpy.loads will convert the string back to an array.
 |      
 |      Parameters
 |      ----------
 |      None
 |  
 |  fill(...)
 |      a.fill(value)
 |      
 |      Fill the array with a scalar value.
 |      
 |      Parameters
 |      ----------
 |      value : scalar
 |          All elements of `a` will be assigned this value.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([1, 2])
 |      >>> a.fill(0)
 |      >>> a
 |      array([0, 0])
 |      >>> a = np.empty(2)
 |      >>> a.fill(1)
 |      >>> a
 |      array([ 1.,  1.])
 |  
 |  flatten(...)
 |      a.flatten(order='C')
 |      
 |      Return a copy of the array collapsed into one dimension.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          'C' means to flatten in row-major (C-style) order.
 |          'F' means to flatten in column-major (Fortran-
 |          style) order. 'A' means to flatten in column-major
 |          order if `a` is Fortran *contiguous* in memory,
 |          row-major order otherwise. 'K' means to flatten
 |          `a` in the order the elements occur in memory.
 |          The default is 'C'.
 |      
 |      Returns
 |      -------
 |      y : ndarray
 |          A copy of the input array, flattened to one dimension.
 |      
 |      See Also
 |      --------
 |      ravel : Return a flattened array.
 |      flat : A 1-D flat iterator over the array.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1,2], [3,4]])
 |      >>> a.flatten()
 |      array([1, 2, 3, 4])
 |      >>> a.flatten('F')
 |      array([1, 3, 2, 4])
 |  
 |  getfield(...)
 |      a.getfield(dtype, offset=0)
 |      
 |      Returns a field of the given array as a certain type.
 |      
 |      A field is a view of the array data with a given data-type. The values in
 |      the view are determined by the given type and the offset into the current
 |      array in bytes. The offset needs to be such that the view dtype fits in the
 |      array dtype; for example an array of dtype complex128 has 16-byte elements.
 |      If taking a view with a 32-bit integer (4 bytes), the offset needs to be
 |      between 0 and 12 bytes.
 |      
 |      Parameters
 |      ----------
 |      dtype : str or dtype
 |          The data type of the view. The dtype size of the view can not be larger
 |          than that of the array itself.
 |      offset : int
 |          Number of bytes to skip before beginning the element view.
 |      
 |      Examples
 |      --------
 |      >>> x = np.diag([1.+1.j]*2)
 |      >>> x[1, 1] = 2 + 4.j
 |      >>> x
 |      array([[ 1.+1.j,  0.+0.j],
 |             [ 0.+0.j,  2.+4.j]])
 |      >>> x.getfield(np.float64)
 |      array([[ 1.,  0.],
 |             [ 0.,  2.]])
 |      
 |      By choosing an offset of 8 bytes we can select the complex part of the
 |      array for our view:
 |      
 |      >>> x.getfield(np.float64, offset=8)
 |      array([[ 1.,  0.],
 |         [ 0.,  4.]])
 |  
 |  item(...)
 |      a.item(*args)
 |      
 |      Copy an element of an array to a standard Python scalar and return it.
 |      
 |      Parameters
 |      ----------
 |      \*args : Arguments (variable number and type)
 |      
 |          * none: in this case, the method only works for arrays
 |            with one element (`a.size == 1`), which element is
 |            copied into a standard Python scalar object and returned.
 |      
 |          * int_type: this argument is interpreted as a flat index into
 |            the array, specifying which element to copy and return.
 |      
 |          * tuple of int_types: functions as does a single int_type argument,
 |            except that the argument is interpreted as an nd-index into the
 |            array.
 |      
 |      Returns
 |      -------
 |      z : Standard Python scalar object
 |          A copy of the specified element of the array as a suitable
 |          Python scalar
 |      
 |      Notes
 |      -----
 |      When the data type of `a` is longdouble or clongdouble, item() returns
 |      a scalar array object because there is no available Python scalar that
 |      would not lose information. Void arrays return a buffer object for item(),
 |      unless fields are defined, in which case a tuple is returned.
 |      
 |      `item` is very similar to a[args], except, instead of an array scalar,
 |      a standard Python scalar is returned. This can be useful for speeding up
 |      access to elements of the array and doing arithmetic on elements of the
 |      array using Python's optimized math.
 |      
 |      Examples
 |      --------
 |      >>> x = np.random.randint(9, size=(3, 3))
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 8, 3],
 |             [8, 5, 3]])
 |      >>> x.item(3)
 |      2
 |      >>> x.item(7)
 |      5
 |      >>> x.item((0, 1))
 |      1
 |      >>> x.item((2, 2))
 |      3
 |  
 |  itemset(...)
 |      a.itemset(*args)
 |      
 |      Insert scalar into an array (scalar is cast to array's dtype, if possible)
 |      
 |      There must be at least 1 argument, and define the last argument
 |      as *item*.  Then, ``a.itemset(*args)`` is equivalent to but faster
 |      than ``a[args] = item``.  The item should be a scalar value and `args`
 |      must select a single item in the array `a`.
 |      
 |      Parameters
 |      ----------
 |      \*args : Arguments
 |          If one argument: a scalar, only used in case `a` is of size 1.
 |          If two arguments: the last argument is the value to be set
 |          and must be a scalar, the first argument specifies a single array
 |          element location. It is either an int or a tuple.
 |      
 |      Notes
 |      -----
 |      Compared to indexing syntax, `itemset` provides some speed increase
 |      for placing a scalar into a particular location in an `ndarray`,
 |      if you must do this.  However, generally this is discouraged:
 |      among other problems, it complicates the appearance of the code.
 |      Also, when using `itemset` (and `item`) inside a loop, be sure
 |      to assign the methods to a local variable to avoid the attribute
 |      look-up at each loop iteration.
 |      
 |      Examples
 |      --------
 |      >>> x = np.random.randint(9, size=(3, 3))
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 8, 3],
 |             [8, 5, 3]])
 |      >>> x.itemset(4, 0)
 |      >>> x.itemset((2, 2), 9)
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 0, 3],
 |             [8, 5, 9]])
 |  
 |  max(...)
 |      a.max(axis=None, out=None, keepdims=False)
 |      
 |      Return the maximum along a given axis.
 |      
 |      Refer to `numpy.amax` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.amax : equivalent function
 |  
 |  mean(...)
 |      a.mean(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Returns the average of the array elements along given axis.
 |      
 |      Refer to `numpy.mean` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.mean : equivalent function
 |  
 |  min(...)
 |      a.min(axis=None, out=None, keepdims=False)
 |      
 |      Return the minimum along a given axis.
 |      
 |      Refer to `numpy.amin` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.amin : equivalent function
 |  
 |  newbyteorder(...)
 |      arr.newbyteorder(new_order='S')
 |      
 |      Return the array with the same data viewed with a different byte order.
 |      
 |      Equivalent to::
 |      
 |          arr.view(arr.dtype.newbytorder(new_order))
 |      
 |      Changes are also made in all fields and sub-arrays of the array data
 |      type.
 |      
 |      
 |      
 |      Parameters
 |      ----------
 |      new_order : string, optional
 |          Byte order to force; a value from the byte order specifications
 |          below. `new_order` codes can be any of:
 |      
 |          * 'S' - swap dtype from current to opposite endian
 |          * {'<', 'L'} - little endian
 |          * {'>', 'B'} - big endian
 |          * {'=', 'N'} - native order
 |          * {'|', 'I'} - ignore (no change to byte order)
 |      
 |          The default value ('S') results in swapping the current
 |          byte order. The code does a case-insensitive check on the first
 |          letter of `new_order` for the alternatives above.  For example,
 |          any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 |      
 |      
 |      Returns
 |      -------
 |      new_arr : array
 |          New array object with the dtype reflecting given change to the
 |          byte order.
 |  
 |  nonzero(...)
 |      a.nonzero()
 |      
 |      Return the indices of the elements that are non-zero.
 |      
 |      Refer to `numpy.nonzero` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.nonzero : equivalent function
 |  
 |  partition(...)
 |      a.partition(kth, axis=-1, kind='introselect', order=None)
 |      
 |      Rearranges the elements in the array in such a way that value of the
 |      element in kth position is in the position it would be in a sorted array.
 |      All elements smaller than the kth element are moved before this element and
 |      all equal or greater are moved behind it. The ordering of the elements in
 |      the two partitions is undefined.
 |      
 |      .. versionadded:: 1.8.0
 |      
 |      Parameters
 |      ----------
 |      kth : int or sequence of ints
 |          Element index to partition by. The kth element value will be in its
 |          final sorted position and all smaller elements will be moved before it
 |          and all equal or greater elements behind it.
 |          The order all elements in the partitions is undefined.
 |          If provided with a sequence of kth it will partition all elements
 |          indexed by kth of them into their sorted position at once.
 |      axis : int, optional
 |          Axis along which to sort. Default is -1, which means sort along the
 |          last axis.
 |      kind : {'introselect'}, optional
 |          Selection algorithm. Default is 'introselect'.
 |      order : str or list of str, optional
 |          When `a` is an array with fields defined, this argument specifies
 |          which fields to compare first, second, etc.  A single field can
 |          be specified as a string, and not all fields need be specified,
 |          but unspecified fields will still be used, in the order in which
 |          they come up in the dtype, to break ties.
 |      
 |      See Also
 |      --------
 |      numpy.partition : Return a parititioned copy of an array.
 |      argpartition : Indirect partition.
 |      sort : Full sort.
 |      
 |      Notes
 |      -----
 |      See ``np.partition`` for notes on the different algorithms.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([3, 4, 2, 1])
 |      >>> a.partition(3)
 |      >>> a
 |      array([2, 1, 3, 4])
 |      
 |      >>> a.partition((1, 3))
 |      array([1, 2, 3, 4])
 |  
 |  prod(...)
 |      a.prod(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Return the product of the array elements over the given axis
 |      
 |      Refer to `numpy.prod` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.prod : equivalent function
 |  
 |  ptp(...)
 |      a.ptp(axis=None, out=None)
 |      
 |      Peak to peak (maximum - minimum) value along a given axis.
 |      
 |      Refer to `numpy.ptp` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.ptp : equivalent function
 |  
 |  put(...)
 |      a.put(indices, values, mode='raise')
 |      
 |      Set ``a.flat[n] = values[n]`` for all `n` in indices.
 |      
 |      Refer to `numpy.put` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.put : equivalent function
 |  
 |  ravel(...)
 |      a.ravel([order])
 |      
 |      Return a flattened array.
 |      
 |      Refer to `numpy.ravel` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.ravel : equivalent function
 |      
 |      ndarray.flat : a flat iterator on the array.
 |  
 |  repeat(...)
 |      a.repeat(repeats, axis=None)
 |      
 |      Repeat elements of an array.
 |      
 |      Refer to `numpy.repeat` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.repeat : equivalent function
 |  
 |  reshape(...)
 |      a.reshape(shape, order='C')
 |      
 |      Returns an array containing the same data with a new shape.
 |      
 |      Refer to `numpy.reshape` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.reshape : equivalent function
 |      
 |      Notes
 |      -----
 |      Unlike the free function `numpy.reshape`, this method on `ndarray` allows
 |      the elements of the shape parameter to be passed in as separate arguments.
 |      For example, ``a.reshape(10, 11)`` is equivalent to
 |      ``a.reshape((10, 11))``.
 |  
 |  resize(...)
 |      a.resize(new_shape, refcheck=True)
 |      
 |      Change shape and size of array in-place.
 |      
 |      Parameters
 |      ----------
 |      new_shape : tuple of ints, or `n` ints
 |          Shape of resized array.
 |      refcheck : bool, optional
 |          If False, reference count will not be checked. Default is True.
 |      
 |      Returns
 |      -------
 |      None
 |      
 |      Raises
 |      ------
 |      ValueError
 |          If `a` does not own its own data or references or views to it exist,
 |          and the data memory must be changed.
 |          PyPy only: will always raise if the data memory must be changed, since
 |          there is no reliable way to determine if references or views to it
 |          exist.
 |      
 |      SystemError
 |          If the `order` keyword argument is specified. This behaviour is a
 |          bug in NumPy.
 |      
 |      See Also
 |      --------
 |      resize : Return a new array with the specified shape.
 |      
 |      Notes
 |      -----
 |      This reallocates space for the data area if necessary.
 |      
 |      Only contiguous arrays (data elements consecutive in memory) can be
 |      resized.
 |      
 |      The purpose of the reference count check is to make sure you
 |      do not use this array as a buffer for another Python object and then
 |      reallocate the memory. However, reference counts can increase in
 |      other ways so if you are sure that you have not shared the memory
 |      for this array with another Python object, then you may safely set
 |      `refcheck` to False.
 |      
 |      Examples
 |      --------
 |      Shrinking an array: array is flattened (in the order that the data are
 |      stored in memory), resized, and reshaped:
 |      
 |      >>> a = np.array([[0, 1], [2, 3]], order='C')
 |      >>> a.resize((2, 1))
 |      >>> a
 |      array([[0],
 |             [1]])
 |      
 |      >>> a = np.array([[0, 1], [2, 3]], order='F')
 |      >>> a.resize((2, 1))
 |      >>> a
 |      array([[0],
 |             [2]])
 |      
 |      Enlarging an array: as above, but missing entries are filled with zeros:
 |      
 |      >>> b = np.array([[0, 1], [2, 3]])
 |      >>> b.resize(2, 3) # new_shape parameter doesn't have to be a tuple
 |      >>> b
 |      array([[0, 1, 2],
 |             [3, 0, 0]])
 |      
 |      Referencing an array prevents resizing...
 |      
 |      >>> c = a
 |      >>> a.resize((1, 1))
 |      Traceback (most recent call last):
 |      ...
 |      ValueError: cannot resize an array that has been referenced ...
 |      
 |      Unless `refcheck` is False:
 |      
 |      >>> a.resize((1, 1), refcheck=False)
 |      >>> a
 |      array([[0]])
 |      >>> c
 |      array([[0]])
 |  
 |  round(...)
 |      a.round(decimals=0, out=None)
 |      
 |      Return `a` with each element rounded to the given number of decimals.
 |      
 |      Refer to `numpy.around` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.around : equivalent function
 |  
 |  searchsorted(...)
 |      a.searchsorted(v, side='left', sorter=None)
 |      
 |      Find indices where elements of v should be inserted in a to maintain order.
 |      
 |      For full documentation, see `numpy.searchsorted`
 |      
 |      See Also
 |      --------
 |      numpy.searchsorted : equivalent function
 |  
 |  setfield(...)
 |      a.setfield(val, dtype, offset=0)
 |      
 |      Put a value into a specified place in a field defined by a data-type.
 |      
 |      Place `val` into `a`'s field defined by `dtype` and beginning `offset`
 |      bytes into the field.
 |      
 |      Parameters
 |      ----------
 |      val : object
 |          Value to be placed in field.
 |      dtype : dtype object
 |          Data-type of the field in which to place `val`.
 |      offset : int, optional
 |          The number of bytes into the field at which to place `val`.
 |      
 |      Returns
 |      -------
 |      None
 |      
 |      See Also
 |      --------
 |      getfield
 |      
 |      Examples
 |      --------
 |      >>> x = np.eye(3)
 |      >>> x.getfield(np.float64)
 |      array([[ 1.,  0.,  0.],
 |             [ 0.,  1.,  0.],
 |             [ 0.,  0.,  1.]])
 |      >>> x.setfield(3, np.int32)
 |      >>> x.getfield(np.int32)
 |      array([[3, 3, 3],
 |             [3, 3, 3],
 |             [3, 3, 3]])
 |      >>> x
 |      array([[  1.00000000e+000,   1.48219694e-323,   1.48219694e-323],
 |             [  1.48219694e-323,   1.00000000e+000,   1.48219694e-323],
 |             [  1.48219694e-323,   1.48219694e-323,   1.00000000e+000]])
 |      >>> x.setfield(np.eye(3), np.int32)
 |      >>> x
 |      array([[ 1.,  0.,  0.],
 |             [ 0.,  1.,  0.],
 |             [ 0.,  0.,  1.]])
 |  
 |  setflags(...)
 |      a.setflags(write=None, align=None, uic=None)
 |      
 |      Set array flags WRITEABLE, ALIGNED, (WRITEBACKIFCOPY and UPDATEIFCOPY),
 |      respectively.
 |      
 |      These Boolean-valued flags affect how numpy interprets the memory
 |      area used by `a` (see Notes below). The ALIGNED flag can only
 |      be set to True if the data is actually aligned according to the type.
 |      The WRITEBACKIFCOPY and (deprecated) UPDATEIFCOPY flags can never be set
 |      to True. The flag WRITEABLE can only be set to True if the array owns its
 |      own memory, or the ultimate owner of the memory exposes a writeable buffer
 |      interface, or is a string. (The exception for string is made so that
 |      unpickling can be done without copying memory.)
 |      
 |      Parameters
 |      ----------
 |      write : bool, optional
 |          Describes whether or not `a` can be written to.
 |      align : bool, optional
 |          Describes whether or not `a` is aligned properly for its type.
 |      uic : bool, optional
 |          Describes whether or not `a` is a copy of another ""base"" array.
 |      
 |      Notes
 |      -----
 |      Array flags provide information about how the memory area used
 |      for the array is to be interpreted. There are 7 Boolean flags
 |      in use, only four of which can be changed by the user:
 |      WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED.
 |      
 |      WRITEABLE (W) the data area can be written to;
 |      
 |      ALIGNED (A) the data and strides are aligned appropriately for the hardware
 |      (as determined by the compiler);
 |      
 |      UPDATEIFCOPY (U) (deprecated), replaced by WRITEBACKIFCOPY;
 |      
 |      WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced
 |      by .base). When the C-API function PyArray_ResolveWritebackIfCopy is
 |      called, the base array will be updated with the contents of this array.
 |      
 |      All flags can be accessed using the single (upper case) letter as well
 |      as the full name.
 |      
 |      Examples
 |      --------
 |      >>> y
 |      array([[3, 1, 7],
 |             [2, 0, 0],
 |             [8, 5, 9]])
 |      >>> y.flags
 |        C_CONTIGUOUS : True
 |        F_CONTIGUOUS : False
 |        OWNDATA : True
 |        WRITEABLE : True
 |        ALIGNED : True
 |        WRITEBACKIFCOPY : False
 |        UPDATEIFCOPY : False
 |      >>> y.setflags(write=0, align=0)
 |      >>> y.flags
 |        C_CONTIGUOUS : True
 |        F_CONTIGUOUS : False
 |        OWNDATA : True
 |        WRITEABLE : False
 |        ALIGNED : False
 |        WRITEBACKIFCOPY : False
 |        UPDATEIFCOPY : False
 |      >>> y.setflags(uic=1)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: cannot set WRITEBACKIFCOPY flag to True
 |  
 |  sort(...)
 |      a.sort(axis=-1, kind='quicksort', order=None)
 |      
 |      Sort an array, in-place.
 |      
 |      Parameters
 |      ----------
 |      axis : int, optional
 |          Axis along which to sort. Default is -1, which means sort along the
 |          last axis.
 |      kind : {'quicksort', 'mergesort', 'heapsort'}, optional
 |          Sorting algorithm. Default is 'quicksort'.
 |      order : str or list of str, optional
 |          When `a` is an array with fields defined, this argument specifies
 |          which fields to compare first, second, etc.  A single field can
 |          be specified as a string, and not all fields need be specified,
 |          but unspecified fields will still be used, in the order in which
 |          they come up in the dtype, to break ties.
 |      
 |      See Also
 |      --------
 |      numpy.sort : Return a sorted copy of an array.
 |      argsort : Indirect sort.
 |      lexsort : Indirect stable sort on multiple keys.
 |      searchsorted : Find elements in sorted array.
 |      partition: Partial sort.
 |      
 |      Notes
 |      -----
 |      See ``sort`` for notes on the different sorting algorithms.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1,4], [3,1]])
 |      >>> a.sort(axis=1)
 |      >>> a
 |      array([[1, 4],
 |             [1, 3]])
 |      >>> a.sort(axis=0)
 |      >>> a
 |      array([[1, 3],
 |             [1, 4]])
 |      
 |      Use the `order` keyword to specify a field to use when sorting a
 |      structured array:
 |      
 |      >>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])
 |      >>> a.sort(order='y')
 |      >>> a
 |      array([('c', 1), ('a', 2)],
 |            dtype=[('x', '|S1'), ('y', '<i4')])
 |  
 |  squeeze(...)
 |      a.squeeze(axis=None)
 |      
 |      Remove single-dimensional entries from the shape of `a`.
 |      
 |      Refer to `numpy.squeeze` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.squeeze : equivalent function
 |  
 |  std(...)
 |      a.std(axis=None, dtype=None, out=None, ddof=0, keepdims=False)
 |      
 |      Returns the standard deviation of the array elements along given axis.
 |      
 |      Refer to `numpy.std` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.std : equivalent function
 |  
 |  sum(...)
 |      a.sum(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Return the sum of the array elements over the given axis.
 |      
 |      Refer to `numpy.sum` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.sum : equivalent function
 |  
 |  swapaxes(...)
 |      a.swapaxes(axis1, axis2)
 |      
 |      Return a view of the array with `axis1` and `axis2` interchanged.
 |      
 |      Refer to `numpy.swapaxes` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.swapaxes : equivalent function
 |  
 |  take(...)
 |      a.take(indices, axis=None, out=None, mode='raise')
 |      
 |      Return an array formed from the elements of `a` at the given indices.
 |      
 |      Refer to `numpy.take` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.take : equivalent function
 |  
 |  tobytes(...)
 |      a.tobytes(order='C')
 |      
 |      Construct Python bytes containing the raw data bytes in the array.
 |      
 |      Constructs Python bytes showing a copy of the raw contents of
 |      data memory. The bytes object can be produced in either 'C' or 'Fortran',
 |      or 'Any' order (the default is 'C'-order). 'Any' order means C-order
 |      unless the F_CONTIGUOUS flag in the array is set, in which case it
 |      means 'Fortran' order.
 |      
 |      .. versionadded:: 1.9.0
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', None}, optional
 |          Order of the data for multidimensional arrays:
 |          C, Fortran, or the same as for the original array.
 |      
 |      Returns
 |      -------
 |      s : bytes
 |          Python bytes exhibiting a copy of `a`'s raw data.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[0, 1], [2, 3]])
 |      >>> x.tobytes()
 |      b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
 |      >>> x.tobytes('C') == x.tobytes()
 |      True
 |      >>> x.tobytes('F')
 |      b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
 |  
 |  tofile(...)
 |      a.tofile(fid, sep="""", format=""%s"")
 |      
 |      Write array to a file as text or binary (default).
 |      
 |      Data is always written in 'C' order, independent of the order of `a`.
 |      The data produced by this method can be recovered using the function
 |      fromfile().
 |      
 |      Parameters
 |      ----------
 |      fid : file or str
 |          An open file object, or a string containing a filename.
 |      sep : str
 |          Separator between array items for text output.
 |          If """" (empty), a binary file is written, equivalent to
 |          ``file.write(a.tobytes())``.
 |      format : str
 |          Format string for text file output.
 |          Each entry in the array is formatted to text by first converting
 |          it to the closest Python type, and then using ""format"" % item.
 |      
 |      Notes
 |      -----
 |      This is a convenience function for quick storage of array data.
 |      Information on endianness and precision is lost, so this method is not a
 |      good choice for files intended to archive data or transport data between
 |      machines with different endianness. Some of these problems can be overcome
 |      by outputting the data as text files, at the expense of speed and file
 |      size.
 |  
 |  tolist(...)
 |      a.tolist()
 |      
 |      Return the array as a (possibly nested) list.
 |      
 |      Return a copy of the array data as a (nested) Python list.
 |      Data items are converted to the nearest compatible Python type.
 |      
 |      Parameters
 |      ----------
 |      none
 |      
 |      Returns
 |      -------
 |      y : list
 |          The possibly nested list of array elements.
 |      
 |      Notes
 |      -----
 |      The array may be recreated, ``a = np.array(a.tolist())``.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([1, 2])
 |      >>> a.tolist()
 |      [1, 2]
 |      >>> a = np.array([[1, 2], [3, 4]])
 |      >>> list(a)
 |      [array([1, 2]), array([3, 4])]
 |      >>> a.tolist()
 |      [[1, 2], [3, 4]]
 |  
 |  tostring(...)
 |      a.tostring(order='C')
 |      
 |      Construct Python bytes containing the raw data bytes in the array.
 |      
 |      Constructs Python bytes showing a copy of the raw contents of
 |      data memory. The bytes object can be produced in either 'C' or 'Fortran',
 |      or 'Any' order (the default is 'C'-order). 'Any' order means C-order
 |      unless the F_CONTIGUOUS flag in the array is set, in which case it
 |      means 'Fortran' order.
 |      
 |      This function is a compatibility alias for tobytes. Despite its name it returns bytes not strings.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', None}, optional
 |          Order of the data for multidimensional arrays:
 |          C, Fortran, or the same as for the original array.
 |      
 |      Returns
 |      -------
 |      s : bytes
 |          Python bytes exhibiting a copy of `a`'s raw data.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[0, 1], [2, 3]])
 |      >>> x.tobytes()
 |      b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
 |      >>> x.tobytes('C') == x.tobytes()
 |      True
 |      >>> x.tobytes('F')
 |      b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
 |  
 |  trace(...)
 |      a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)
 |      
 |      Return the sum along diagonals of the array.
 |      
 |      Refer to `numpy.trace` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.trace : equivalent function
 |  
 |  transpose(...)
 |      a.transpose(*axes)
 |      
 |      Returns a view of the array with axes transposed.
 |      
 |      For a 1-D array, this has no effect. (To change between column and
 |      row vectors, first cast the 1-D array into a matrix object.)
 |      For a 2-D array, this is the usual matrix transpose.
 |      For an n-D array, if axes are given, their order indicates how the
 |      axes are permuted (see Examples). If axes are not provided and
 |      ``a.shape = (i[0], i[1], ... i[n-2], i[n-1])``, then
 |      ``a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0])``.
 |      
 |      Parameters
 |      ----------
 |      axes : None, tuple of ints, or `n` ints
 |      
 |       * None or no argument: reverses the order of the axes.
 |      
 |       * tuple of ints: `i` in the `j`-th place in the tuple means `a`'s
 |         `i`-th axis becomes `a.transpose()`'s `j`-th axis.
 |      
 |       * `n` ints: same as an n-tuple of the same ints (this form is
 |         intended simply as a ""convenience"" alternative to the tuple form)
 |      
 |      Returns
 |      -------
 |      out : ndarray
 |          View of `a`, with axes suitably permuted.
 |      
 |      See Also
 |      --------
 |      ndarray.T : Array property returning the array transposed.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1, 2], [3, 4]])
 |      >>> a
 |      array([[1, 2],
 |             [3, 4]])
 |      >>> a.transpose()
 |      array([[1, 3],
 |             [2, 4]])
 |      >>> a.transpose((1, 0))
 |      array([[1, 3],
 |             [2, 4]])
 |      >>> a.transpose(1, 0)
 |      array([[1, 3],
 |             [2, 4]])
 |  
 |  var(...)
 |      a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False)
 |      
 |      Returns the variance of the array elements, along given axis.
 |      
 |      Refer to `numpy.var` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.var : equivalent function
 |  
 |  view(...)
 |      a.view(dtype=None, type=None)
 |      
 |      New view of array with the same data.
 |      
 |      Parameters
 |      ----------
 |      dtype : data-type or ndarray sub-class, optional
 |          Data-type descriptor of the returned view, e.g., float32 or int16. The
 |          default, None, results in the view having the same data-type as `a`.
 |          This argument can also be specified as an ndarray sub-class, which
 |          then specifies the type of the returned object (this is equivalent to
 |          setting the ``type`` parameter).
 |      type : Python type, optional
 |          Type of the returned view, e.g., ndarray or matrix.  Again, the
 |          default None results in type preservation.
 |      
 |      Notes
 |      -----
 |      ``a.view()`` is used two different ways:
 |      
 |      ``a.view(some_dtype)`` or ``a.view(dtype=some_dtype)`` constructs a view
 |      of the array's memory with a different data-type.  This can cause a
 |      reinterpretation of the bytes of memory.
 |      
 |      ``a.view(ndarray_subclass)`` or ``a.view(type=ndarray_subclass)`` just
 |      returns an instance of `ndarray_subclass` that looks at the same array
 |      (same shape, dtype, etc.)  This does not cause a reinterpretation of the
 |      memory.
 |      
 |      For ``a.view(some_dtype)``, if ``some_dtype`` has a different number of
 |      bytes per entry than the previous dtype (for example, converting a
 |      regular array to a structured array), then the behavior of the view
 |      cannot be predicted just from the superficial appearance of ``a`` (shown
 |      by ``print(a)``). It also depends on exactly how ``a`` is stored in
 |      memory. Therefore if ``a`` is C-ordered versus fortran-ordered, versus
 |      defined as a slice or transpose, etc., the view may give different
 |      results.
 |      
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])
 |      
 |      Viewing array data using a different type and dtype:
 |      
 |      >>> y = x.view(dtype=np.int16, type=np.matrix)
 |      >>> y
 |      matrix([[513]], dtype=int16)
 |      >>> print(type(y))
 |      <class 'numpy.matrixlib.defmatrix.matrix'>
 |      
 |      Creating a view on a structured array so it can be used in calculations
 |      
 |      >>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)])
 |      >>> xv = x.view(dtype=np.int8).reshape(-1,2)
 |      >>> xv
 |      array([[1, 2],
 |             [3, 4]], dtype=int8)
 |      >>> xv.mean(0)
 |      array([ 2.,  3.])
 |      
 |      Making changes to the view changes the underlying array
 |      
 |      >>> xv[0,1] = 20
 |      >>> print(x)
 |      [(1, 20) (3, 4)]
 |      
 |      Using a view to convert an array to a recarray:
 |      
 |      >>> z = x.view(np.recarray)
 |      >>> z.a
 |      array([1], dtype=int8)
 |      
 |      Views share data:
 |      
 |      >>> x[0] = (9, 10)
 |      >>> z[0]
 |      (9, 10)
 |      
 |      Views that change the dtype size (bytes per entry) should normally be
 |      avoided on arrays defined by slices, transposes, fortran-ordering, etc.:
 |      
 |      >>> x = np.array([[1,2,3],[4,5,6]], dtype=np.int16)
 |      >>> y = x[:, 0:2]
 |      >>> y
 |      array([[1, 2],
 |             [4, 5]], dtype=int16)
 |      >>> y.view(dtype=[('width', np.int16), ('length', np.int16)])
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: new type not compatible with array.
 |      >>> z = y.copy()
 |      >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
 |      array([[(1, 2)],
 |             [(4, 5)]], dtype=[('width', '<i2'), ('length', '<i2')])
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from numpy.ndarray:
 |  
 |  T
 |      Same as self.transpose(), except that self is returned if
 |      self.ndim < 2.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[1.,2.],[3.,4.]])
 |      >>> x
 |      array([[ 1.,  2.],
 |             [ 3.,  4.]])
 |      >>> x.T
 |      array([[ 1.,  3.],
 |             [ 2.,  4.]])
 |      >>> x = np.array([1.,2.,3.,4.])
 |      >>> x
 |      array([ 1.,  2.,  3.,  4.])
 |      >>> x.T
 |      array([ 1.,  2.,  3.,  4.])
 |  
 |  __array_interface__
 |      Array protocol: Python side.
 |  
 |  __array_priority__
 |      Array priority.
 |  
 |  __array_struct__
 |      Array protocol: C-struct side.
 |  
 |  base
 |      Base object if memory is from some other object.
 |      
 |      Examples
 |      --------
 |      The base of an array that owns its memory is None:
 |      
 |      >>> x = np.array([1,2,3,4])
 |      >>> x.base is None
 |      True
 |      
 |      Slicing creates a view, whose memory is shared with x:
 |      
 |      >>> y = x[2:]
 |      >>> y.base is x
 |      True
 |  
 |  ctypes
 |      An object to simplify the interaction of the array with the ctypes
 |      module.
 |      
 |      This attribute creates an object that makes it easier to use arrays
 |      when calling shared libraries with the ctypes module. The returned
 |      object has, among others, data, shape, and strides attributes (see
 |      Notes below) which themselves return ctypes objects that can be used
 |      as arguments to a shared library.
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      c : Python object
 |          Possessing attributes data, shape, strides, etc.
 |      
 |      See Also
 |      --------
 |      numpy.ctypeslib
 |      
 |      Notes
 |      -----
 |      Below are the public attributes of this object which were documented
 |      in ""Guide to NumPy"" (we have omitted undocumented public attributes,
 |      as well as documented private attributes):
 |      
 |      * data: A pointer to the memory area of the array as a Python integer.
 |        This memory area may contain data that is not aligned, or not in correct
 |        byte-order. The memory area may not even be writeable. The array
 |        flags and data-type of this array should be respected when passing this
 |        attribute to arbitrary C-code to avoid trouble that can include Python
 |        crashing. User Beware! The value of this attribute is exactly the same
 |        as self._array_interface_['data'][0].
 |      
 |      * shape (c_intp*self.ndim): A ctypes array of length self.ndim where
 |        the basetype is the C-integer corresponding to dtype('p') on this
 |        platform. This base-type could be c_int, c_long, or c_longlong
 |        depending on the platform. The c_intp type is defined accordingly in
 |        numpy.ctypeslib. The ctypes array contains the shape of the underlying
 |        array.
 |      
 |      * strides (c_intp*self.ndim): A ctypes array of length self.ndim where
 |        the basetype is the same as for the shape attribute. This ctypes array
 |        contains the strides information from the underlying array. This strides
 |        information is important for showing how many bytes must be jumped to
 |        get to the next element in the array.
 |      
 |      * data_as(obj): Return the data pointer cast to a particular c-types object.
 |        For example, calling self._as_parameter_ is equivalent to
 |        self.data_as(ctypes.c_void_p). Perhaps you want to use the data as a
 |        pointer to a ctypes array of floating-point data:
 |        self.data_as(ctypes.POINTER(ctypes.c_double)).
 |      
 |      * shape_as(obj): Return the shape tuple as an array of some other c-types
 |        type. For example: self.shape_as(ctypes.c_short).
 |      
 |      * strides_as(obj): Return the strides tuple as an array of some other
 |        c-types type. For example: self.strides_as(ctypes.c_longlong).
 |      
 |      Be careful using the ctypes attribute - especially on temporary
 |      arrays or arrays constructed on the fly. For example, calling
 |      ``(a+b).ctypes.data_as(ctypes.c_void_p)`` returns a pointer to memory
 |      that is invalid because the array created as (a+b) is deallocated
 |      before the next Python statement. You can avoid this problem using
 |      either ``c=a+b`` or ``ct=(a+b).ctypes``. In the latter case, ct will
 |      hold a reference to the array until ct is deleted or re-assigned.
 |      
 |      If the ctypes module is not available, then the ctypes attribute
 |      of array objects still returns something useful, but ctypes objects
 |      are not returned and errors may be raised instead. In particular,
 |      the object will still have the as parameter attribute which will
 |      return an integer equal to the data attribute.
 |      
 |      Examples
 |      --------
 |      >>> import ctypes
 |      >>> x
 |      array([[0, 1],
 |             [2, 3]])
 |      >>> x.ctypes.data
 |      30439712
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long))
 |      <ctypes.LP_c_long object at 0x01F01300>
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)).contents
 |      c_long(0)
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_longlong)).contents
 |      c_longlong(4294967296L)
 |      >>> x.ctypes.shape
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FFD580>
 |      >>> x.ctypes.shape_as(ctypes.c_long)
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
 |      >>> x.ctypes.strides
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
 |      >>> x.ctypes.strides_as(ctypes.c_longlong)
 |      <numpy.core._internal.c_longlong_Array_2 object at 0x01F01300>
 |  
 |  data
 |      Python buffer object pointing to the start of the array's data.
 |  
 |  dtype
 |      Data-type of the array's elements.
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      d : numpy dtype object
 |      
 |      See Also
 |      --------
 |      numpy.dtype
 |      
 |      Examples
 |      --------
 |      >>> x
 |      array([[0, 1],
 |             [2, 3]])
 |      >>> x.dtype
 |      dtype('int32')
 |      >>> type(x.dtype)
 |      <type 'numpy.dtype'>
 |  
 |  flags
 |      Information about the memory layout of the array.
 |      
 |      Attributes
 |      ----------
 |      C_CONTIGUOUS (C)
 |          The data is in a single, C-style contiguous segment.
 |      F_CONTIGUOUS (F)
 |          The data is in a single, Fortran-style contiguous segment.
 |      OWNDATA (O)
 |          The array owns the memory it uses or borrows it from another object.
 |      WRITEABLE (W)
 |          The data area can be written to.  Setting this to False locks
 |          the data, making it read-only.  A view (slice, etc.) inherits WRITEABLE
 |          from its base array at creation time, but a view of a writeable
 |          array may be subsequently locked while the base array remains writeable.
 |          (The opposite is not true, in that a view of a locked array may not
 |          be made writeable.  However, currently, locking a base object does not
 |          lock any views that already reference it, so under that circumstance it
 |          is possible to alter the contents of a locked array via a previously
 |          created writeable view onto it.)  Attempting to change a non-writeable
 |          array raises a RuntimeError exception.
 |      ALIGNED (A)
 |          The data and all elements are aligned appropriately for the hardware.
 |      WRITEBACKIFCOPY (X)
 |          This array is a copy of some other array. The C-API function
 |          PyArray_ResolveWritebackIfCopy must be called before deallocating
 |          to the base array will be updated with the contents of this array.
 |      UPDATEIFCOPY (U)
 |          (Deprecated, use WRITEBACKIFCOPY) This array is a copy of some other array.
 |          When this array is
 |          deallocated, the base array will be updated with the contents of
 |          this array.
 |      FNC
 |          F_CONTIGUOUS and not C_CONTIGUOUS.
 |      FORC
 |          F_CONTIGUOUS or C_CONTIGUOUS (one-segment test).
 |      BEHAVED (B)
 |          ALIGNED and WRITEABLE.
 |      CARRAY (CA)
 |          BEHAVED and C_CONTIGUOUS.
 |      FARRAY (FA)
 |          BEHAVED and F_CONTIGUOUS and not C_CONTIGUOUS.
 |      
 |      Notes
 |      -----
 |      The `flags` object can be accessed dictionary-like (as in ``a.flags['WRITEABLE']``),
 |      or by using lowercased attribute names (as in ``a.flags.writeable``). Short flag
 |      names are only supported in dictionary access.
 |      
 |      Only the WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED flags can be
 |      changed by the user, via direct assignment to the attribute or dictionary
 |      entry, or by calling `ndarray.setflags`.
 |      
 |      The array flags cannot be set arbitrarily:
 |      
 |      - UPDATEIFCOPY can only be set ``False``.
 |      - WRITEBACKIFCOPY can only be set ``False``.
 |      - ALIGNED can only be set ``True`` if the data is truly aligned.
 |      - WRITEABLE can only be set ``True`` if the array owns its own memory
 |        or the ultimate owner of the memory exposes a writeable buffer
 |        interface or is a string.
 |      
 |      Arrays can be both C-style and Fortran-style contiguous simultaneously.
 |      This is clear for 1-dimensional arrays, but can also be true for higher
 |      dimensional arrays.
 |      
 |      Even for contiguous arrays a stride for a given dimension
 |      ``arr.strides[dim]`` may be *arbitrary* if ``arr.shape[dim] == 1``
 |      or the array has no elements.
 |      It does *not* generally hold that ``self.strides[-1] == self.itemsize``
 |      for C-style contiguous arrays or ``self.strides[0] == self.itemsize`` for
 |      Fortran-style contiguous arrays is true.
 |  
 |  flat
 |      A 1-D iterator over the array.
 |      
 |      This is a `numpy.flatiter` instance, which acts similarly to, but is not
 |      a subclass of, Python's built-in iterator object.
 |      
 |      See Also
 |      --------
 |      flatten : Return a copy of the array collapsed into one dimension.
 |      
 |      flatiter
 |      
 |      Examples
 |      --------
 |      >>> x = np.arange(1, 7).reshape(2, 3)
 |      >>> x
 |      array([[1, 2, 3],
 |             [4, 5, 6]])
 |      >>> x.flat[3]
 |      4
 |      >>> x.T
 |      array([[1, 4],
 |             [2, 5],
 |             [3, 6]])
 |      >>> x.T.flat[3]
 |      5
 |      >>> type(x.flat)
 |      <type 'numpy.flatiter'>
 |      
 |      An assignment example:
 |      
 |      >>> x.flat = 3; x
 |      array([[3, 3, 3],
 |             [3, 3, 3]])
 |      >>> x.flat[[1,4]] = 1; x
 |      array([[3, 1, 3],
 |             [3, 1, 3]])
 |  
 |  imag
 |      The imaginary part of the array.
 |      
 |      Examples
 |      --------
 |      >>> x = np.sqrt([1+0j, 0+1j])
 |      >>> x.imag
 |      array([ 0.        ,  0.70710678])
 |      >>> x.imag.dtype
 |      dtype('float64')
 |  
 |  itemsize
 |      Length of one array element in bytes.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1,2,3], dtype=np.float64)
 |      >>> x.itemsize
 |      8
 |      >>> x = np.array([1,2,3], dtype=np.complex128)
 |      >>> x.itemsize
 |      16
 |  
 |  nbytes
 |      Total bytes consumed by the elements of the array.
 |      
 |      Notes
 |      -----
 |      Does not include memory consumed by non-element attributes of the
 |      array object.
 |      
 |      Examples
 |      --------
 |      >>> x = np.zeros((3,5,2), dtype=np.complex128)
 |      >>> x.nbytes
 |      480
 |      >>> np.prod(x.shape) * x.itemsize
 |      480
 |  
 |  ndim
 |      Number of array dimensions.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 3])
 |      >>> x.ndim
 |      1
 |      >>> y = np.zeros((2, 3, 4))
 |      >>> y.ndim
 |      3
 |  
 |  real
 |      The real part of the array.
 |      
 |      Examples
 |      --------
 |      >>> x = np.sqrt([1+0j, 0+1j])
 |      >>> x.real
 |      array([ 1.        ,  0.70710678])
 |      >>> x.real.dtype
 |      dtype('float64')
 |      
 |      See Also
 |      --------
 |      numpy.real : equivalent function
 |  
 |  shape
 |      Tuple of array dimensions.
 |      
 |      The shape property is usually used to get the current shape of an array,
 |      but may also be used to reshape the array in-place by assigning a tuple of
 |      array dimensions to it.  As with `numpy.reshape`, one of the new shape
 |      dimensions can be -1, in which case its value is inferred from the size of
 |      the array and the remaining dimensions. Reshaping an array in-place will
 |      fail if a copy is required.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 3, 4])
 |      >>> x.shape
 |      (4,)
 |      >>> y = np.zeros((2, 3, 4))
 |      >>> y.shape
 |      (2, 3, 4)
 |      >>> y.shape = (3, 8)
 |      >>> y
 |      array([[ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
 |             [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
 |             [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.]])
 |      >>> y.shape = (3, 6)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: total size of new array must be unchanged
 |      >>> np.zeros((4,2))[::2].shape = (-1,)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      AttributeError: incompatible shape for a non-contiguous array
 |      
 |      See Also
 |      --------
 |      numpy.reshape : similar function
 |      ndarray.reshape : similar method
 |  
 |  size
 |      Number of elements in the array.
 |      
 |      Equivalent to ``np.prod(a.shape)``, i.e., the product of the array's
 |      dimensions.
 |      
 |      Examples
 |      --------
 |      >>> x = np.zeros((3, 5, 2), dtype=np.complex128)
 |      >>> x.size
 |      30
 |      >>> np.prod(x.shape)
 |      30
 |  
 |  strides
 |      Tuple of bytes to step in each dimension when traversing an array.
 |      
 |      The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a`
 |      is::
 |      
 |          offset = sum(np.array(i) * a.strides)
 |      
 |      A more detailed explanation of strides can be found in the
 |      ""ndarray.rst"" file in the NumPy reference guide.
 |      
 |      Notes
 |      -----
 |      Imagine an array of 32-bit integers (each 4 bytes)::
 |      
 |        x = np.array([[0, 1, 2, 3, 4],
 |                      [5, 6, 7, 8, 9]], dtype=np.int32)
 |      
 |      This array is stored in memory as 40 bytes, one after the other
 |      (known as a contiguous block of memory).  The strides of an array tell
 |      us how many bytes we have to skip in memory to move to the next position
 |      along a certain axis.  For example, we have to skip 4 bytes (1 value) to
 |      move to the next column, but 20 bytes (5 values) to get to the same
 |      position in the next row.  As such, the strides for the array `x` will be
 |      ``(20, 4)``.
 |      
 |      See Also
 |      --------
 |      numpy.lib.stride_tricks.as_strided
 |      
 |      Examples
 |      --------
 |      >>> y = np.reshape(np.arange(2*3*4), (2,3,4))
 |      >>> y
 |      array([[[ 0,  1,  2,  3],
 |              [ 4,  5,  6,  7],
 |              [ 8,  9, 10, 11]],
 |             [[12, 13, 14, 15],
 |              [16, 17, 18, 19],
 |              [20, 21, 22, 23]]])
 |      >>> y.strides
 |      (48, 16, 4)
 |      >>> y[1,1,1]
 |      17
 |      >>> offset=sum(y.strides * np.array((1,1,1)))
 |      >>> offset/y.itemsize
 |      17
 |      
 |      >>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0)
 |      >>> x.strides
 |      (32, 4, 224, 1344)
 |      >>> i = np.array([3,5,2,2])
 |      >>> offset = sum(i * x.strides)
 |      >>> x[3,5,2,2]
 |      813
 |      >>> offset / x.itemsize
 |      813
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from numpy.ndarray:
 |  
 |  __hash__ = None
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.matlab.mio5_params.MatlabOpaque,io.matlab.mio5_params,MatlabOpaque,"Python Library Documentation: class MatlabOpaque in module scipy.io.matlab.mio5_params

class MatlabOpaque(numpy.ndarray)
 |  Subclass to signal this is a matlab opaque matrix
 |  
 |  Method resolution order:
 |      MatlabOpaque
 |      numpy.ndarray
 |      builtins.object
 |  
 |  Static methods defined here:
 |  
 |  __new__(cls, input_array)
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from numpy.ndarray:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __array__(...)
 |      a.__array__(|dtype) -> reference if type unchanged, copy otherwise.
 |      
 |      Returns either a new reference to self if dtype is not given or a new array
 |      of provided data type if dtype is different from the current dtype of the
 |      array.
 |  
 |  __array_prepare__(...)
 |      a.__array_prepare__(obj) -> Object of same type as ndarray object obj.
 |  
 |  __array_ufunc__(...)
 |  
 |  __array_wrap__(...)
 |      a.__array_wrap__(obj) -> Object of same type as ndarray object a.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __complex__(...)
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __copy__(...)
 |      a.__copy__()
 |      
 |      Used if :func:`copy.copy` is called on an array. Returns a copy of the array.
 |      
 |      Equivalent to ``a.copy(order='K')``.
 |  
 |  __deepcopy__(...)
 |      a.__deepcopy__(memo, /) -> Deep copy of array.
 |      
 |      Used if :func:`copy.deepcopy` is called on an array.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __format__(...)
 |      default object formatter
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iadd__(self, value, /)
 |      Return self+=value.
 |  
 |  __iand__(self, value, /)
 |      Return self&=value.
 |  
 |  __ifloordiv__(self, value, /)
 |      Return self//=value.
 |  
 |  __ilshift__(self, value, /)
 |      Return self<<=value.
 |  
 |  __imatmul__(self, value, /)
 |      Return self@=value.
 |  
 |  __imod__(self, value, /)
 |      Return self%=value.
 |  
 |  __imul__(self, value, /)
 |      Return self*=value.
 |  
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __ior__(self, value, /)
 |      Return self|=value.
 |  
 |  __ipow__(self, value, /)
 |      Return self**=value.
 |  
 |  __irshift__(self, value, /)
 |      Return self>>=value.
 |  
 |  __isub__(self, value, /)
 |      Return self-=value.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __itruediv__(self, value, /)
 |      Return self/=value.
 |  
 |  __ixor__(self, value, /)
 |      Return self^=value.
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __matmul__(self, value, /)
 |      Return self@value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __reduce__(...)
 |      a.__reduce__()
 |      
 |      For pickling.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmatmul__(self, value, /)
 |      Return value@self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __setstate__(...)
 |      a.__setstate__(state, /)
 |      
 |      For unpickling.
 |      
 |      The `state` argument must be a sequence that contains the following
 |      elements:
 |      
 |      Parameters
 |      ----------
 |      version : int
 |          optional pickle version. If omitted defaults to 0.
 |      shape : tuple
 |      dtype : data-type
 |      isFortran : bool
 |      rawdata : string or list
 |          a binary string with the data (or a list if 'a' is an object array)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  all(...)
 |      a.all(axis=None, out=None, keepdims=False)
 |      
 |      Returns True if all elements evaluate to True.
 |      
 |      Refer to `numpy.all` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.all : equivalent function
 |  
 |  any(...)
 |      a.any(axis=None, out=None, keepdims=False)
 |      
 |      Returns True if any of the elements of `a` evaluate to True.
 |      
 |      Refer to `numpy.any` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.any : equivalent function
 |  
 |  argmax(...)
 |      a.argmax(axis=None, out=None)
 |      
 |      Return indices of the maximum values along the given axis.
 |      
 |      Refer to `numpy.argmax` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argmax : equivalent function
 |  
 |  argmin(...)
 |      a.argmin(axis=None, out=None)
 |      
 |      Return indices of the minimum values along the given axis of `a`.
 |      
 |      Refer to `numpy.argmin` for detailed documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argmin : equivalent function
 |  
 |  argpartition(...)
 |      a.argpartition(kth, axis=-1, kind='introselect', order=None)
 |      
 |      Returns the indices that would partition this array.
 |      
 |      Refer to `numpy.argpartition` for full documentation.
 |      
 |      .. versionadded:: 1.8.0
 |      
 |      See Also
 |      --------
 |      numpy.argpartition : equivalent function
 |  
 |  argsort(...)
 |      a.argsort(axis=-1, kind='quicksort', order=None)
 |      
 |      Returns the indices that would sort this array.
 |      
 |      Refer to `numpy.argsort` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argsort : equivalent function
 |  
 |  astype(...)
 |      a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)
 |      
 |      Copy of the array, cast to a specified type.
 |      
 |      Parameters
 |      ----------
 |      dtype : str or dtype
 |          Typecode or data-type to which the array is cast.
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          Controls the memory layout order of the result.
 |          'C' means C order, 'F' means Fortran order, 'A'
 |          means 'F' order if all the arrays are Fortran contiguous,
 |          'C' order otherwise, and 'K' means as close to the
 |          order the array elements appear in memory as possible.
 |          Default is 'K'.
 |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
 |          Controls what kind of data casting may occur. Defaults to 'unsafe'
 |          for backwards compatibility.
 |      
 |            * 'no' means the data types should not be cast at all.
 |            * 'equiv' means only byte-order changes are allowed.
 |            * 'safe' means only casts which can preserve values are allowed.
 |            * 'same_kind' means only safe casts or casts within a kind,
 |              like float64 to float32, are allowed.
 |            * 'unsafe' means any data conversions may be done.
 |      subok : bool, optional
 |          If True, then sub-classes will be passed-through (default), otherwise
 |          the returned array will be forced to be a base-class array.
 |      copy : bool, optional
 |          By default, astype always returns a newly allocated array. If this
 |          is set to false, and the `dtype`, `order`, and `subok`
 |          requirements are satisfied, the input array is returned instead
 |          of a copy.
 |      
 |      Returns
 |      -------
 |      arr_t : ndarray
 |          Unless `copy` is False and the other conditions for returning the input
 |          array are satisfied (see description for `copy` input parameter), `arr_t`
 |          is a new array of the same shape as the input array, with dtype, order
 |          given by `dtype`, `order`.
 |      
 |      Notes
 |      -----
 |      Starting in NumPy 1.9, astype method now returns an error if the string
 |      dtype to cast to is not long enough in 'safe' casting mode to hold the max
 |      value of integer/float array that is being casted. Previously the casting
 |      was allowed even if the result was truncated.
 |      
 |      Raises
 |      ------
 |      ComplexWarning
 |          When casting from complex to float or int. To avoid this,
 |          one should use ``a.real.astype(t)``.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 2.5])
 |      >>> x
 |      array([ 1. ,  2. ,  2.5])
 |      
 |      >>> x.astype(int)
 |      array([1, 2, 2])
 |  
 |  byteswap(...)
 |      a.byteswap(inplace=False)
 |      
 |      Swap the bytes of the array elements
 |      
 |      Toggle between low-endian and big-endian data representation by
 |      returning a byteswapped array, optionally swapped in-place.
 |      
 |      Parameters
 |      ----------
 |      inplace : bool, optional
 |          If ``True``, swap bytes in-place, default is ``False``.
 |      
 |      Returns
 |      -------
 |      out : ndarray
 |          The byteswapped array. If `inplace` is ``True``, this is
 |          a view to self.
 |      
 |      Examples
 |      --------
 |      >>> A = np.array([1, 256, 8755], dtype=np.int16)
 |      >>> map(hex, A)
 |      ['0x1', '0x100', '0x2233']
 |      >>> A.byteswap(inplace=True)
 |      array([  256,     1, 13090], dtype=int16)
 |      >>> map(hex, A)
 |      ['0x100', '0x1', '0x3322']
 |      
 |      Arrays of strings are not swapped
 |      
 |      >>> A = np.array(['ceg', 'fac'])
 |      >>> A.byteswap()
 |      array(['ceg', 'fac'],
 |            dtype='|S3')
 |  
 |  choose(...)
 |      a.choose(choices, out=None, mode='raise')
 |      
 |      Use an index array to construct a new array from a set of choices.
 |      
 |      Refer to `numpy.choose` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.choose : equivalent function
 |  
 |  clip(...)
 |      a.clip(min=None, max=None, out=None)
 |      
 |      Return an array whose values are limited to ``[min, max]``.
 |      One of max or min must be given.
 |      
 |      Refer to `numpy.clip` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.clip : equivalent function
 |  
 |  compress(...)
 |      a.compress(condition, axis=None, out=None)
 |      
 |      Return selected slices of this array along given axis.
 |      
 |      Refer to `numpy.compress` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.compress : equivalent function
 |  
 |  conj(...)
 |      a.conj()
 |      
 |      Complex-conjugate all elements.
 |      
 |      Refer to `numpy.conjugate` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.conjugate : equivalent function
 |  
 |  conjugate(...)
 |      a.conjugate()
 |      
 |      Return the complex conjugate, element-wise.
 |      
 |      Refer to `numpy.conjugate` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.conjugate : equivalent function
 |  
 |  copy(...)
 |      a.copy(order='C')
 |      
 |      Return a copy of the array.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          Controls the memory layout of the copy. 'C' means C-order,
 |          'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
 |          'C' otherwise. 'K' means match the layout of `a` as closely
 |          as possible. (Note that this function and :func:`numpy.copy` are very
 |          similar, but have different default values for their order=
 |          arguments.)
 |      
 |      See also
 |      --------
 |      numpy.copy
 |      numpy.copyto
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[1,2,3],[4,5,6]], order='F')
 |      
 |      >>> y = x.copy()
 |      
 |      >>> x.fill(0)
 |      
 |      >>> x
 |      array([[0, 0, 0],
 |             [0, 0, 0]])
 |      
 |      >>> y
 |      array([[1, 2, 3],
 |             [4, 5, 6]])
 |      
 |      >>> y.flags['C_CONTIGUOUS']
 |      True
 |  
 |  cumprod(...)
 |      a.cumprod(axis=None, dtype=None, out=None)
 |      
 |      Return the cumulative product of the elements along the given axis.
 |      
 |      Refer to `numpy.cumprod` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.cumprod : equivalent function
 |  
 |  cumsum(...)
 |      a.cumsum(axis=None, dtype=None, out=None)
 |      
 |      Return the cumulative sum of the elements along the given axis.
 |      
 |      Refer to `numpy.cumsum` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.cumsum : equivalent function
 |  
 |  diagonal(...)
 |      a.diagonal(offset=0, axis1=0, axis2=1)
 |      
 |      Return specified diagonals. In NumPy 1.9 the returned array is a
 |      read-only view instead of a copy as in previous NumPy versions.  In
 |      a future version the read-only restriction will be removed.
 |      
 |      Refer to :func:`numpy.diagonal` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.diagonal : equivalent function
 |  
 |  dot(...)
 |      a.dot(b, out=None)
 |      
 |      Dot product of two arrays.
 |      
 |      Refer to `numpy.dot` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.dot : equivalent function
 |      
 |      Examples
 |      --------
 |      >>> a = np.eye(2)
 |      >>> b = np.ones((2, 2)) * 2
 |      >>> a.dot(b)
 |      array([[ 2.,  2.],
 |             [ 2.,  2.]])
 |      
 |      This array method can be conveniently chained:
 |      
 |      >>> a.dot(b).dot(b)
 |      array([[ 8.,  8.],
 |             [ 8.,  8.]])
 |  
 |  dump(...)
 |      a.dump(file)
 |      
 |      Dump a pickle of the array to the specified file.
 |      The array can be read back with pickle.load or numpy.load.
 |      
 |      Parameters
 |      ----------
 |      file : str
 |          A string naming the dump file.
 |  
 |  dumps(...)
 |      a.dumps()
 |      
 |      Returns the pickle of the array as a string.
 |      pickle.loads or numpy.loads will convert the string back to an array.
 |      
 |      Parameters
 |      ----------
 |      None
 |  
 |  fill(...)
 |      a.fill(value)
 |      
 |      Fill the array with a scalar value.
 |      
 |      Parameters
 |      ----------
 |      value : scalar
 |          All elements of `a` will be assigned this value.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([1, 2])
 |      >>> a.fill(0)
 |      >>> a
 |      array([0, 0])
 |      >>> a = np.empty(2)
 |      >>> a.fill(1)
 |      >>> a
 |      array([ 1.,  1.])
 |  
 |  flatten(...)
 |      a.flatten(order='C')
 |      
 |      Return a copy of the array collapsed into one dimension.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          'C' means to flatten in row-major (C-style) order.
 |          'F' means to flatten in column-major (Fortran-
 |          style) order. 'A' means to flatten in column-major
 |          order if `a` is Fortran *contiguous* in memory,
 |          row-major order otherwise. 'K' means to flatten
 |          `a` in the order the elements occur in memory.
 |          The default is 'C'.
 |      
 |      Returns
 |      -------
 |      y : ndarray
 |          A copy of the input array, flattened to one dimension.
 |      
 |      See Also
 |      --------
 |      ravel : Return a flattened array.
 |      flat : A 1-D flat iterator over the array.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1,2], [3,4]])
 |      >>> a.flatten()
 |      array([1, 2, 3, 4])
 |      >>> a.flatten('F')
 |      array([1, 3, 2, 4])
 |  
 |  getfield(...)
 |      a.getfield(dtype, offset=0)
 |      
 |      Returns a field of the given array as a certain type.
 |      
 |      A field is a view of the array data with a given data-type. The values in
 |      the view are determined by the given type and the offset into the current
 |      array in bytes. The offset needs to be such that the view dtype fits in the
 |      array dtype; for example an array of dtype complex128 has 16-byte elements.
 |      If taking a view with a 32-bit integer (4 bytes), the offset needs to be
 |      between 0 and 12 bytes.
 |      
 |      Parameters
 |      ----------
 |      dtype : str or dtype
 |          The data type of the view. The dtype size of the view can not be larger
 |          than that of the array itself.
 |      offset : int
 |          Number of bytes to skip before beginning the element view.
 |      
 |      Examples
 |      --------
 |      >>> x = np.diag([1.+1.j]*2)
 |      >>> x[1, 1] = 2 + 4.j
 |      >>> x
 |      array([[ 1.+1.j,  0.+0.j],
 |             [ 0.+0.j,  2.+4.j]])
 |      >>> x.getfield(np.float64)
 |      array([[ 1.,  0.],
 |             [ 0.,  2.]])
 |      
 |      By choosing an offset of 8 bytes we can select the complex part of the
 |      array for our view:
 |      
 |      >>> x.getfield(np.float64, offset=8)
 |      array([[ 1.,  0.],
 |         [ 0.,  4.]])
 |  
 |  item(...)
 |      a.item(*args)
 |      
 |      Copy an element of an array to a standard Python scalar and return it.
 |      
 |      Parameters
 |      ----------
 |      \*args : Arguments (variable number and type)
 |      
 |          * none: in this case, the method only works for arrays
 |            with one element (`a.size == 1`), which element is
 |            copied into a standard Python scalar object and returned.
 |      
 |          * int_type: this argument is interpreted as a flat index into
 |            the array, specifying which element to copy and return.
 |      
 |          * tuple of int_types: functions as does a single int_type argument,
 |            except that the argument is interpreted as an nd-index into the
 |            array.
 |      
 |      Returns
 |      -------
 |      z : Standard Python scalar object
 |          A copy of the specified element of the array as a suitable
 |          Python scalar
 |      
 |      Notes
 |      -----
 |      When the data type of `a` is longdouble or clongdouble, item() returns
 |      a scalar array object because there is no available Python scalar that
 |      would not lose information. Void arrays return a buffer object for item(),
 |      unless fields are defined, in which case a tuple is returned.
 |      
 |      `item` is very similar to a[args], except, instead of an array scalar,
 |      a standard Python scalar is returned. This can be useful for speeding up
 |      access to elements of the array and doing arithmetic on elements of the
 |      array using Python's optimized math.
 |      
 |      Examples
 |      --------
 |      >>> x = np.random.randint(9, size=(3, 3))
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 8, 3],
 |             [8, 5, 3]])
 |      >>> x.item(3)
 |      2
 |      >>> x.item(7)
 |      5
 |      >>> x.item((0, 1))
 |      1
 |      >>> x.item((2, 2))
 |      3
 |  
 |  itemset(...)
 |      a.itemset(*args)
 |      
 |      Insert scalar into an array (scalar is cast to array's dtype, if possible)
 |      
 |      There must be at least 1 argument, and define the last argument
 |      as *item*.  Then, ``a.itemset(*args)`` is equivalent to but faster
 |      than ``a[args] = item``.  The item should be a scalar value and `args`
 |      must select a single item in the array `a`.
 |      
 |      Parameters
 |      ----------
 |      \*args : Arguments
 |          If one argument: a scalar, only used in case `a` is of size 1.
 |          If two arguments: the last argument is the value to be set
 |          and must be a scalar, the first argument specifies a single array
 |          element location. It is either an int or a tuple.
 |      
 |      Notes
 |      -----
 |      Compared to indexing syntax, `itemset` provides some speed increase
 |      for placing a scalar into a particular location in an `ndarray`,
 |      if you must do this.  However, generally this is discouraged:
 |      among other problems, it complicates the appearance of the code.
 |      Also, when using `itemset` (and `item`) inside a loop, be sure
 |      to assign the methods to a local variable to avoid the attribute
 |      look-up at each loop iteration.
 |      
 |      Examples
 |      --------
 |      >>> x = np.random.randint(9, size=(3, 3))
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 8, 3],
 |             [8, 5, 3]])
 |      >>> x.itemset(4, 0)
 |      >>> x.itemset((2, 2), 9)
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 0, 3],
 |             [8, 5, 9]])
 |  
 |  max(...)
 |      a.max(axis=None, out=None, keepdims=False)
 |      
 |      Return the maximum along a given axis.
 |      
 |      Refer to `numpy.amax` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.amax : equivalent function
 |  
 |  mean(...)
 |      a.mean(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Returns the average of the array elements along given axis.
 |      
 |      Refer to `numpy.mean` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.mean : equivalent function
 |  
 |  min(...)
 |      a.min(axis=None, out=None, keepdims=False)
 |      
 |      Return the minimum along a given axis.
 |      
 |      Refer to `numpy.amin` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.amin : equivalent function
 |  
 |  newbyteorder(...)
 |      arr.newbyteorder(new_order='S')
 |      
 |      Return the array with the same data viewed with a different byte order.
 |      
 |      Equivalent to::
 |      
 |          arr.view(arr.dtype.newbytorder(new_order))
 |      
 |      Changes are also made in all fields and sub-arrays of the array data
 |      type.
 |      
 |      
 |      
 |      Parameters
 |      ----------
 |      new_order : string, optional
 |          Byte order to force; a value from the byte order specifications
 |          below. `new_order` codes can be any of:
 |      
 |          * 'S' - swap dtype from current to opposite endian
 |          * {'<', 'L'} - little endian
 |          * {'>', 'B'} - big endian
 |          * {'=', 'N'} - native order
 |          * {'|', 'I'} - ignore (no change to byte order)
 |      
 |          The default value ('S') results in swapping the current
 |          byte order. The code does a case-insensitive check on the first
 |          letter of `new_order` for the alternatives above.  For example,
 |          any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 |      
 |      
 |      Returns
 |      -------
 |      new_arr : array
 |          New array object with the dtype reflecting given change to the
 |          byte order.
 |  
 |  nonzero(...)
 |      a.nonzero()
 |      
 |      Return the indices of the elements that are non-zero.
 |      
 |      Refer to `numpy.nonzero` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.nonzero : equivalent function
 |  
 |  partition(...)
 |      a.partition(kth, axis=-1, kind='introselect', order=None)
 |      
 |      Rearranges the elements in the array in such a way that value of the
 |      element in kth position is in the position it would be in a sorted array.
 |      All elements smaller than the kth element are moved before this element and
 |      all equal or greater are moved behind it. The ordering of the elements in
 |      the two partitions is undefined.
 |      
 |      .. versionadded:: 1.8.0
 |      
 |      Parameters
 |      ----------
 |      kth : int or sequence of ints
 |          Element index to partition by. The kth element value will be in its
 |          final sorted position and all smaller elements will be moved before it
 |          and all equal or greater elements behind it.
 |          The order all elements in the partitions is undefined.
 |          If provided with a sequence of kth it will partition all elements
 |          indexed by kth of them into their sorted position at once.
 |      axis : int, optional
 |          Axis along which to sort. Default is -1, which means sort along the
 |          last axis.
 |      kind : {'introselect'}, optional
 |          Selection algorithm. Default is 'introselect'.
 |      order : str or list of str, optional
 |          When `a` is an array with fields defined, this argument specifies
 |          which fields to compare first, second, etc.  A single field can
 |          be specified as a string, and not all fields need be specified,
 |          but unspecified fields will still be used, in the order in which
 |          they come up in the dtype, to break ties.
 |      
 |      See Also
 |      --------
 |      numpy.partition : Return a parititioned copy of an array.
 |      argpartition : Indirect partition.
 |      sort : Full sort.
 |      
 |      Notes
 |      -----
 |      See ``np.partition`` for notes on the different algorithms.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([3, 4, 2, 1])
 |      >>> a.partition(3)
 |      >>> a
 |      array([2, 1, 3, 4])
 |      
 |      >>> a.partition((1, 3))
 |      array([1, 2, 3, 4])
 |  
 |  prod(...)
 |      a.prod(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Return the product of the array elements over the given axis
 |      
 |      Refer to `numpy.prod` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.prod : equivalent function
 |  
 |  ptp(...)
 |      a.ptp(axis=None, out=None)
 |      
 |      Peak to peak (maximum - minimum) value along a given axis.
 |      
 |      Refer to `numpy.ptp` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.ptp : equivalent function
 |  
 |  put(...)
 |      a.put(indices, values, mode='raise')
 |      
 |      Set ``a.flat[n] = values[n]`` for all `n` in indices.
 |      
 |      Refer to `numpy.put` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.put : equivalent function
 |  
 |  ravel(...)
 |      a.ravel([order])
 |      
 |      Return a flattened array.
 |      
 |      Refer to `numpy.ravel` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.ravel : equivalent function
 |      
 |      ndarray.flat : a flat iterator on the array.
 |  
 |  repeat(...)
 |      a.repeat(repeats, axis=None)
 |      
 |      Repeat elements of an array.
 |      
 |      Refer to `numpy.repeat` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.repeat : equivalent function
 |  
 |  reshape(...)
 |      a.reshape(shape, order='C')
 |      
 |      Returns an array containing the same data with a new shape.
 |      
 |      Refer to `numpy.reshape` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.reshape : equivalent function
 |      
 |      Notes
 |      -----
 |      Unlike the free function `numpy.reshape`, this method on `ndarray` allows
 |      the elements of the shape parameter to be passed in as separate arguments.
 |      For example, ``a.reshape(10, 11)`` is equivalent to
 |      ``a.reshape((10, 11))``.
 |  
 |  resize(...)
 |      a.resize(new_shape, refcheck=True)
 |      
 |      Change shape and size of array in-place.
 |      
 |      Parameters
 |      ----------
 |      new_shape : tuple of ints, or `n` ints
 |          Shape of resized array.
 |      refcheck : bool, optional
 |          If False, reference count will not be checked. Default is True.
 |      
 |      Returns
 |      -------
 |      None
 |      
 |      Raises
 |      ------
 |      ValueError
 |          If `a` does not own its own data or references or views to it exist,
 |          and the data memory must be changed.
 |          PyPy only: will always raise if the data memory must be changed, since
 |          there is no reliable way to determine if references or views to it
 |          exist.
 |      
 |      SystemError
 |          If the `order` keyword argument is specified. This behaviour is a
 |          bug in NumPy.
 |      
 |      See Also
 |      --------
 |      resize : Return a new array with the specified shape.
 |      
 |      Notes
 |      -----
 |      This reallocates space for the data area if necessary.
 |      
 |      Only contiguous arrays (data elements consecutive in memory) can be
 |      resized.
 |      
 |      The purpose of the reference count check is to make sure you
 |      do not use this array as a buffer for another Python object and then
 |      reallocate the memory. However, reference counts can increase in
 |      other ways so if you are sure that you have not shared the memory
 |      for this array with another Python object, then you may safely set
 |      `refcheck` to False.
 |      
 |      Examples
 |      --------
 |      Shrinking an array: array is flattened (in the order that the data are
 |      stored in memory), resized, and reshaped:
 |      
 |      >>> a = np.array([[0, 1], [2, 3]], order='C')
 |      >>> a.resize((2, 1))
 |      >>> a
 |      array([[0],
 |             [1]])
 |      
 |      >>> a = np.array([[0, 1], [2, 3]], order='F')
 |      >>> a.resize((2, 1))
 |      >>> a
 |      array([[0],
 |             [2]])
 |      
 |      Enlarging an array: as above, but missing entries are filled with zeros:
 |      
 |      >>> b = np.array([[0, 1], [2, 3]])
 |      >>> b.resize(2, 3) # new_shape parameter doesn't have to be a tuple
 |      >>> b
 |      array([[0, 1, 2],
 |             [3, 0, 0]])
 |      
 |      Referencing an array prevents resizing...
 |      
 |      >>> c = a
 |      >>> a.resize((1, 1))
 |      Traceback (most recent call last):
 |      ...
 |      ValueError: cannot resize an array that has been referenced ...
 |      
 |      Unless `refcheck` is False:
 |      
 |      >>> a.resize((1, 1), refcheck=False)
 |      >>> a
 |      array([[0]])
 |      >>> c
 |      array([[0]])
 |  
 |  round(...)
 |      a.round(decimals=0, out=None)
 |      
 |      Return `a` with each element rounded to the given number of decimals.
 |      
 |      Refer to `numpy.around` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.around : equivalent function
 |  
 |  searchsorted(...)
 |      a.searchsorted(v, side='left', sorter=None)
 |      
 |      Find indices where elements of v should be inserted in a to maintain order.
 |      
 |      For full documentation, see `numpy.searchsorted`
 |      
 |      See Also
 |      --------
 |      numpy.searchsorted : equivalent function
 |  
 |  setfield(...)
 |      a.setfield(val, dtype, offset=0)
 |      
 |      Put a value into a specified place in a field defined by a data-type.
 |      
 |      Place `val` into `a`'s field defined by `dtype` and beginning `offset`
 |      bytes into the field.
 |      
 |      Parameters
 |      ----------
 |      val : object
 |          Value to be placed in field.
 |      dtype : dtype object
 |          Data-type of the field in which to place `val`.
 |      offset : int, optional
 |          The number of bytes into the field at which to place `val`.
 |      
 |      Returns
 |      -------
 |      None
 |      
 |      See Also
 |      --------
 |      getfield
 |      
 |      Examples
 |      --------
 |      >>> x = np.eye(3)
 |      >>> x.getfield(np.float64)
 |      array([[ 1.,  0.,  0.],
 |             [ 0.,  1.,  0.],
 |             [ 0.,  0.,  1.]])
 |      >>> x.setfield(3, np.int32)
 |      >>> x.getfield(np.int32)
 |      array([[3, 3, 3],
 |             [3, 3, 3],
 |             [3, 3, 3]])
 |      >>> x
 |      array([[  1.00000000e+000,   1.48219694e-323,   1.48219694e-323],
 |             [  1.48219694e-323,   1.00000000e+000,   1.48219694e-323],
 |             [  1.48219694e-323,   1.48219694e-323,   1.00000000e+000]])
 |      >>> x.setfield(np.eye(3), np.int32)
 |      >>> x
 |      array([[ 1.,  0.,  0.],
 |             [ 0.,  1.,  0.],
 |             [ 0.,  0.,  1.]])
 |  
 |  setflags(...)
 |      a.setflags(write=None, align=None, uic=None)
 |      
 |      Set array flags WRITEABLE, ALIGNED, (WRITEBACKIFCOPY and UPDATEIFCOPY),
 |      respectively.
 |      
 |      These Boolean-valued flags affect how numpy interprets the memory
 |      area used by `a` (see Notes below). The ALIGNED flag can only
 |      be set to True if the data is actually aligned according to the type.
 |      The WRITEBACKIFCOPY and (deprecated) UPDATEIFCOPY flags can never be set
 |      to True. The flag WRITEABLE can only be set to True if the array owns its
 |      own memory, or the ultimate owner of the memory exposes a writeable buffer
 |      interface, or is a string. (The exception for string is made so that
 |      unpickling can be done without copying memory.)
 |      
 |      Parameters
 |      ----------
 |      write : bool, optional
 |          Describes whether or not `a` can be written to.
 |      align : bool, optional
 |          Describes whether or not `a` is aligned properly for its type.
 |      uic : bool, optional
 |          Describes whether or not `a` is a copy of another ""base"" array.
 |      
 |      Notes
 |      -----
 |      Array flags provide information about how the memory area used
 |      for the array is to be interpreted. There are 7 Boolean flags
 |      in use, only four of which can be changed by the user:
 |      WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED.
 |      
 |      WRITEABLE (W) the data area can be written to;
 |      
 |      ALIGNED (A) the data and strides are aligned appropriately for the hardware
 |      (as determined by the compiler);
 |      
 |      UPDATEIFCOPY (U) (deprecated), replaced by WRITEBACKIFCOPY;
 |      
 |      WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced
 |      by .base). When the C-API function PyArray_ResolveWritebackIfCopy is
 |      called, the base array will be updated with the contents of this array.
 |      
 |      All flags can be accessed using the single (upper case) letter as well
 |      as the full name.
 |      
 |      Examples
 |      --------
 |      >>> y
 |      array([[3, 1, 7],
 |             [2, 0, 0],
 |             [8, 5, 9]])
 |      >>> y.flags
 |        C_CONTIGUOUS : True
 |        F_CONTIGUOUS : False
 |        OWNDATA : True
 |        WRITEABLE : True
 |        ALIGNED : True
 |        WRITEBACKIFCOPY : False
 |        UPDATEIFCOPY : False
 |      >>> y.setflags(write=0, align=0)
 |      >>> y.flags
 |        C_CONTIGUOUS : True
 |        F_CONTIGUOUS : False
 |        OWNDATA : True
 |        WRITEABLE : False
 |        ALIGNED : False
 |        WRITEBACKIFCOPY : False
 |        UPDATEIFCOPY : False
 |      >>> y.setflags(uic=1)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: cannot set WRITEBACKIFCOPY flag to True
 |  
 |  sort(...)
 |      a.sort(axis=-1, kind='quicksort', order=None)
 |      
 |      Sort an array, in-place.
 |      
 |      Parameters
 |      ----------
 |      axis : int, optional
 |          Axis along which to sort. Default is -1, which means sort along the
 |          last axis.
 |      kind : {'quicksort', 'mergesort', 'heapsort'}, optional
 |          Sorting algorithm. Default is 'quicksort'.
 |      order : str or list of str, optional
 |          When `a` is an array with fields defined, this argument specifies
 |          which fields to compare first, second, etc.  A single field can
 |          be specified as a string, and not all fields need be specified,
 |          but unspecified fields will still be used, in the order in which
 |          they come up in the dtype, to break ties.
 |      
 |      See Also
 |      --------
 |      numpy.sort : Return a sorted copy of an array.
 |      argsort : Indirect sort.
 |      lexsort : Indirect stable sort on multiple keys.
 |      searchsorted : Find elements in sorted array.
 |      partition: Partial sort.
 |      
 |      Notes
 |      -----
 |      See ``sort`` for notes on the different sorting algorithms.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1,4], [3,1]])
 |      >>> a.sort(axis=1)
 |      >>> a
 |      array([[1, 4],
 |             [1, 3]])
 |      >>> a.sort(axis=0)
 |      >>> a
 |      array([[1, 3],
 |             [1, 4]])
 |      
 |      Use the `order` keyword to specify a field to use when sorting a
 |      structured array:
 |      
 |      >>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])
 |      >>> a.sort(order='y')
 |      >>> a
 |      array([('c', 1), ('a', 2)],
 |            dtype=[('x', '|S1'), ('y', '<i4')])
 |  
 |  squeeze(...)
 |      a.squeeze(axis=None)
 |      
 |      Remove single-dimensional entries from the shape of `a`.
 |      
 |      Refer to `numpy.squeeze` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.squeeze : equivalent function
 |  
 |  std(...)
 |      a.std(axis=None, dtype=None, out=None, ddof=0, keepdims=False)
 |      
 |      Returns the standard deviation of the array elements along given axis.
 |      
 |      Refer to `numpy.std` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.std : equivalent function
 |  
 |  sum(...)
 |      a.sum(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Return the sum of the array elements over the given axis.
 |      
 |      Refer to `numpy.sum` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.sum : equivalent function
 |  
 |  swapaxes(...)
 |      a.swapaxes(axis1, axis2)
 |      
 |      Return a view of the array with `axis1` and `axis2` interchanged.
 |      
 |      Refer to `numpy.swapaxes` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.swapaxes : equivalent function
 |  
 |  take(...)
 |      a.take(indices, axis=None, out=None, mode='raise')
 |      
 |      Return an array formed from the elements of `a` at the given indices.
 |      
 |      Refer to `numpy.take` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.take : equivalent function
 |  
 |  tobytes(...)
 |      a.tobytes(order='C')
 |      
 |      Construct Python bytes containing the raw data bytes in the array.
 |      
 |      Constructs Python bytes showing a copy of the raw contents of
 |      data memory. The bytes object can be produced in either 'C' or 'Fortran',
 |      or 'Any' order (the default is 'C'-order). 'Any' order means C-order
 |      unless the F_CONTIGUOUS flag in the array is set, in which case it
 |      means 'Fortran' order.
 |      
 |      .. versionadded:: 1.9.0
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', None}, optional
 |          Order of the data for multidimensional arrays:
 |          C, Fortran, or the same as for the original array.
 |      
 |      Returns
 |      -------
 |      s : bytes
 |          Python bytes exhibiting a copy of `a`'s raw data.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[0, 1], [2, 3]])
 |      >>> x.tobytes()
 |      b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
 |      >>> x.tobytes('C') == x.tobytes()
 |      True
 |      >>> x.tobytes('F')
 |      b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
 |  
 |  tofile(...)
 |      a.tofile(fid, sep="""", format=""%s"")
 |      
 |      Write array to a file as text or binary (default).
 |      
 |      Data is always written in 'C' order, independent of the order of `a`.
 |      The data produced by this method can be recovered using the function
 |      fromfile().
 |      
 |      Parameters
 |      ----------
 |      fid : file or str
 |          An open file object, or a string containing a filename.
 |      sep : str
 |          Separator between array items for text output.
 |          If """" (empty), a binary file is written, equivalent to
 |          ``file.write(a.tobytes())``.
 |      format : str
 |          Format string for text file output.
 |          Each entry in the array is formatted to text by first converting
 |          it to the closest Python type, and then using ""format"" % item.
 |      
 |      Notes
 |      -----
 |      This is a convenience function for quick storage of array data.
 |      Information on endianness and precision is lost, so this method is not a
 |      good choice for files intended to archive data or transport data between
 |      machines with different endianness. Some of these problems can be overcome
 |      by outputting the data as text files, at the expense of speed and file
 |      size.
 |  
 |  tolist(...)
 |      a.tolist()
 |      
 |      Return the array as a (possibly nested) list.
 |      
 |      Return a copy of the array data as a (nested) Python list.
 |      Data items are converted to the nearest compatible Python type.
 |      
 |      Parameters
 |      ----------
 |      none
 |      
 |      Returns
 |      -------
 |      y : list
 |          The possibly nested list of array elements.
 |      
 |      Notes
 |      -----
 |      The array may be recreated, ``a = np.array(a.tolist())``.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([1, 2])
 |      >>> a.tolist()
 |      [1, 2]
 |      >>> a = np.array([[1, 2], [3, 4]])
 |      >>> list(a)
 |      [array([1, 2]), array([3, 4])]
 |      >>> a.tolist()
 |      [[1, 2], [3, 4]]
 |  
 |  tostring(...)
 |      a.tostring(order='C')
 |      
 |      Construct Python bytes containing the raw data bytes in the array.
 |      
 |      Constructs Python bytes showing a copy of the raw contents of
 |      data memory. The bytes object can be produced in either 'C' or 'Fortran',
 |      or 'Any' order (the default is 'C'-order). 'Any' order means C-order
 |      unless the F_CONTIGUOUS flag in the array is set, in which case it
 |      means 'Fortran' order.
 |      
 |      This function is a compatibility alias for tobytes. Despite its name it returns bytes not strings.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', None}, optional
 |          Order of the data for multidimensional arrays:
 |          C, Fortran, or the same as for the original array.
 |      
 |      Returns
 |      -------
 |      s : bytes
 |          Python bytes exhibiting a copy of `a`'s raw data.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[0, 1], [2, 3]])
 |      >>> x.tobytes()
 |      b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
 |      >>> x.tobytes('C') == x.tobytes()
 |      True
 |      >>> x.tobytes('F')
 |      b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
 |  
 |  trace(...)
 |      a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)
 |      
 |      Return the sum along diagonals of the array.
 |      
 |      Refer to `numpy.trace` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.trace : equivalent function
 |  
 |  transpose(...)
 |      a.transpose(*axes)
 |      
 |      Returns a view of the array with axes transposed.
 |      
 |      For a 1-D array, this has no effect. (To change between column and
 |      row vectors, first cast the 1-D array into a matrix object.)
 |      For a 2-D array, this is the usual matrix transpose.
 |      For an n-D array, if axes are given, their order indicates how the
 |      axes are permuted (see Examples). If axes are not provided and
 |      ``a.shape = (i[0], i[1], ... i[n-2], i[n-1])``, then
 |      ``a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0])``.
 |      
 |      Parameters
 |      ----------
 |      axes : None, tuple of ints, or `n` ints
 |      
 |       * None or no argument: reverses the order of the axes.
 |      
 |       * tuple of ints: `i` in the `j`-th place in the tuple means `a`'s
 |         `i`-th axis becomes `a.transpose()`'s `j`-th axis.
 |      
 |       * `n` ints: same as an n-tuple of the same ints (this form is
 |         intended simply as a ""convenience"" alternative to the tuple form)
 |      
 |      Returns
 |      -------
 |      out : ndarray
 |          View of `a`, with axes suitably permuted.
 |      
 |      See Also
 |      --------
 |      ndarray.T : Array property returning the array transposed.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1, 2], [3, 4]])
 |      >>> a
 |      array([[1, 2],
 |             [3, 4]])
 |      >>> a.transpose()
 |      array([[1, 3],
 |             [2, 4]])
 |      >>> a.transpose((1, 0))
 |      array([[1, 3],
 |             [2, 4]])
 |      >>> a.transpose(1, 0)
 |      array([[1, 3],
 |             [2, 4]])
 |  
 |  var(...)
 |      a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False)
 |      
 |      Returns the variance of the array elements, along given axis.
 |      
 |      Refer to `numpy.var` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.var : equivalent function
 |  
 |  view(...)
 |      a.view(dtype=None, type=None)
 |      
 |      New view of array with the same data.
 |      
 |      Parameters
 |      ----------
 |      dtype : data-type or ndarray sub-class, optional
 |          Data-type descriptor of the returned view, e.g., float32 or int16. The
 |          default, None, results in the view having the same data-type as `a`.
 |          This argument can also be specified as an ndarray sub-class, which
 |          then specifies the type of the returned object (this is equivalent to
 |          setting the ``type`` parameter).
 |      type : Python type, optional
 |          Type of the returned view, e.g., ndarray or matrix.  Again, the
 |          default None results in type preservation.
 |      
 |      Notes
 |      -----
 |      ``a.view()`` is used two different ways:
 |      
 |      ``a.view(some_dtype)`` or ``a.view(dtype=some_dtype)`` constructs a view
 |      of the array's memory with a different data-type.  This can cause a
 |      reinterpretation of the bytes of memory.
 |      
 |      ``a.view(ndarray_subclass)`` or ``a.view(type=ndarray_subclass)`` just
 |      returns an instance of `ndarray_subclass` that looks at the same array
 |      (same shape, dtype, etc.)  This does not cause a reinterpretation of the
 |      memory.
 |      
 |      For ``a.view(some_dtype)``, if ``some_dtype`` has a different number of
 |      bytes per entry than the previous dtype (for example, converting a
 |      regular array to a structured array), then the behavior of the view
 |      cannot be predicted just from the superficial appearance of ``a`` (shown
 |      by ``print(a)``). It also depends on exactly how ``a`` is stored in
 |      memory. Therefore if ``a`` is C-ordered versus fortran-ordered, versus
 |      defined as a slice or transpose, etc., the view may give different
 |      results.
 |      
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])
 |      
 |      Viewing array data using a different type and dtype:
 |      
 |      >>> y = x.view(dtype=np.int16, type=np.matrix)
 |      >>> y
 |      matrix([[513]], dtype=int16)
 |      >>> print(type(y))
 |      <class 'numpy.matrixlib.defmatrix.matrix'>
 |      
 |      Creating a view on a structured array so it can be used in calculations
 |      
 |      >>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)])
 |      >>> xv = x.view(dtype=np.int8).reshape(-1,2)
 |      >>> xv
 |      array([[1, 2],
 |             [3, 4]], dtype=int8)
 |      >>> xv.mean(0)
 |      array([ 2.,  3.])
 |      
 |      Making changes to the view changes the underlying array
 |      
 |      >>> xv[0,1] = 20
 |      >>> print(x)
 |      [(1, 20) (3, 4)]
 |      
 |      Using a view to convert an array to a recarray:
 |      
 |      >>> z = x.view(np.recarray)
 |      >>> z.a
 |      array([1], dtype=int8)
 |      
 |      Views share data:
 |      
 |      >>> x[0] = (9, 10)
 |      >>> z[0]
 |      (9, 10)
 |      
 |      Views that change the dtype size (bytes per entry) should normally be
 |      avoided on arrays defined by slices, transposes, fortran-ordering, etc.:
 |      
 |      >>> x = np.array([[1,2,3],[4,5,6]], dtype=np.int16)
 |      >>> y = x[:, 0:2]
 |      >>> y
 |      array([[1, 2],
 |             [4, 5]], dtype=int16)
 |      >>> y.view(dtype=[('width', np.int16), ('length', np.int16)])
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: new type not compatible with array.
 |      >>> z = y.copy()
 |      >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
 |      array([[(1, 2)],
 |             [(4, 5)]], dtype=[('width', '<i2'), ('length', '<i2')])
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from numpy.ndarray:
 |  
 |  T
 |      Same as self.transpose(), except that self is returned if
 |      self.ndim < 2.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[1.,2.],[3.,4.]])
 |      >>> x
 |      array([[ 1.,  2.],
 |             [ 3.,  4.]])
 |      >>> x.T
 |      array([[ 1.,  3.],
 |             [ 2.,  4.]])
 |      >>> x = np.array([1.,2.,3.,4.])
 |      >>> x
 |      array([ 1.,  2.,  3.,  4.])
 |      >>> x.T
 |      array([ 1.,  2.,  3.,  4.])
 |  
 |  __array_finalize__
 |      None.
 |  
 |  __array_interface__
 |      Array protocol: Python side.
 |  
 |  __array_priority__
 |      Array priority.
 |  
 |  __array_struct__
 |      Array protocol: C-struct side.
 |  
 |  base
 |      Base object if memory is from some other object.
 |      
 |      Examples
 |      --------
 |      The base of an array that owns its memory is None:
 |      
 |      >>> x = np.array([1,2,3,4])
 |      >>> x.base is None
 |      True
 |      
 |      Slicing creates a view, whose memory is shared with x:
 |      
 |      >>> y = x[2:]
 |      >>> y.base is x
 |      True
 |  
 |  ctypes
 |      An object to simplify the interaction of the array with the ctypes
 |      module.
 |      
 |      This attribute creates an object that makes it easier to use arrays
 |      when calling shared libraries with the ctypes module. The returned
 |      object has, among others, data, shape, and strides attributes (see
 |      Notes below) which themselves return ctypes objects that can be used
 |      as arguments to a shared library.
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      c : Python object
 |          Possessing attributes data, shape, strides, etc.
 |      
 |      See Also
 |      --------
 |      numpy.ctypeslib
 |      
 |      Notes
 |      -----
 |      Below are the public attributes of this object which were documented
 |      in ""Guide to NumPy"" (we have omitted undocumented public attributes,
 |      as well as documented private attributes):
 |      
 |      * data: A pointer to the memory area of the array as a Python integer.
 |        This memory area may contain data that is not aligned, or not in correct
 |        byte-order. The memory area may not even be writeable. The array
 |        flags and data-type of this array should be respected when passing this
 |        attribute to arbitrary C-code to avoid trouble that can include Python
 |        crashing. User Beware! The value of this attribute is exactly the same
 |        as self._array_interface_['data'][0].
 |      
 |      * shape (c_intp*self.ndim): A ctypes array of length self.ndim where
 |        the basetype is the C-integer corresponding to dtype('p') on this
 |        platform. This base-type could be c_int, c_long, or c_longlong
 |        depending on the platform. The c_intp type is defined accordingly in
 |        numpy.ctypeslib. The ctypes array contains the shape of the underlying
 |        array.
 |      
 |      * strides (c_intp*self.ndim): A ctypes array of length self.ndim where
 |        the basetype is the same as for the shape attribute. This ctypes array
 |        contains the strides information from the underlying array. This strides
 |        information is important for showing how many bytes must be jumped to
 |        get to the next element in the array.
 |      
 |      * data_as(obj): Return the data pointer cast to a particular c-types object.
 |        For example, calling self._as_parameter_ is equivalent to
 |        self.data_as(ctypes.c_void_p). Perhaps you want to use the data as a
 |        pointer to a ctypes array of floating-point data:
 |        self.data_as(ctypes.POINTER(ctypes.c_double)).
 |      
 |      * shape_as(obj): Return the shape tuple as an array of some other c-types
 |        type. For example: self.shape_as(ctypes.c_short).
 |      
 |      * strides_as(obj): Return the strides tuple as an array of some other
 |        c-types type. For example: self.strides_as(ctypes.c_longlong).
 |      
 |      Be careful using the ctypes attribute - especially on temporary
 |      arrays or arrays constructed on the fly. For example, calling
 |      ``(a+b).ctypes.data_as(ctypes.c_void_p)`` returns a pointer to memory
 |      that is invalid because the array created as (a+b) is deallocated
 |      before the next Python statement. You can avoid this problem using
 |      either ``c=a+b`` or ``ct=(a+b).ctypes``. In the latter case, ct will
 |      hold a reference to the array until ct is deleted or re-assigned.
 |      
 |      If the ctypes module is not available, then the ctypes attribute
 |      of array objects still returns something useful, but ctypes objects
 |      are not returned and errors may be raised instead. In particular,
 |      the object will still have the as parameter attribute which will
 |      return an integer equal to the data attribute.
 |      
 |      Examples
 |      --------
 |      >>> import ctypes
 |      >>> x
 |      array([[0, 1],
 |             [2, 3]])
 |      >>> x.ctypes.data
 |      30439712
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long))
 |      <ctypes.LP_c_long object at 0x01F01300>
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)).contents
 |      c_long(0)
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_longlong)).contents
 |      c_longlong(4294967296L)
 |      >>> x.ctypes.shape
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FFD580>
 |      >>> x.ctypes.shape_as(ctypes.c_long)
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
 |      >>> x.ctypes.strides
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
 |      >>> x.ctypes.strides_as(ctypes.c_longlong)
 |      <numpy.core._internal.c_longlong_Array_2 object at 0x01F01300>
 |  
 |  data
 |      Python buffer object pointing to the start of the array's data.
 |  
 |  dtype
 |      Data-type of the array's elements.
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      d : numpy dtype object
 |      
 |      See Also
 |      --------
 |      numpy.dtype
 |      
 |      Examples
 |      --------
 |      >>> x
 |      array([[0, 1],
 |             [2, 3]])
 |      >>> x.dtype
 |      dtype('int32')
 |      >>> type(x.dtype)
 |      <type 'numpy.dtype'>
 |  
 |  flags
 |      Information about the memory layout of the array.
 |      
 |      Attributes
 |      ----------
 |      C_CONTIGUOUS (C)
 |          The data is in a single, C-style contiguous segment.
 |      F_CONTIGUOUS (F)
 |          The data is in a single, Fortran-style contiguous segment.
 |      OWNDATA (O)
 |          The array owns the memory it uses or borrows it from another object.
 |      WRITEABLE (W)
 |          The data area can be written to.  Setting this to False locks
 |          the data, making it read-only.  A view (slice, etc.) inherits WRITEABLE
 |          from its base array at creation time, but a view of a writeable
 |          array may be subsequently locked while the base array remains writeable.
 |          (The opposite is not true, in that a view of a locked array may not
 |          be made writeable.  However, currently, locking a base object does not
 |          lock any views that already reference it, so under that circumstance it
 |          is possible to alter the contents of a locked array via a previously
 |          created writeable view onto it.)  Attempting to change a non-writeable
 |          array raises a RuntimeError exception.
 |      ALIGNED (A)
 |          The data and all elements are aligned appropriately for the hardware.
 |      WRITEBACKIFCOPY (X)
 |          This array is a copy of some other array. The C-API function
 |          PyArray_ResolveWritebackIfCopy must be called before deallocating
 |          to the base array will be updated with the contents of this array.
 |      UPDATEIFCOPY (U)
 |          (Deprecated, use WRITEBACKIFCOPY) This array is a copy of some other array.
 |          When this array is
 |          deallocated, the base array will be updated with the contents of
 |          this array.
 |      FNC
 |          F_CONTIGUOUS and not C_CONTIGUOUS.
 |      FORC
 |          F_CONTIGUOUS or C_CONTIGUOUS (one-segment test).
 |      BEHAVED (B)
 |          ALIGNED and WRITEABLE.
 |      CARRAY (CA)
 |          BEHAVED and C_CONTIGUOUS.
 |      FARRAY (FA)
 |          BEHAVED and F_CONTIGUOUS and not C_CONTIGUOUS.
 |      
 |      Notes
 |      -----
 |      The `flags` object can be accessed dictionary-like (as in ``a.flags['WRITEABLE']``),
 |      or by using lowercased attribute names (as in ``a.flags.writeable``). Short flag
 |      names are only supported in dictionary access.
 |      
 |      Only the WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED flags can be
 |      changed by the user, via direct assignment to the attribute or dictionary
 |      entry, or by calling `ndarray.setflags`.
 |      
 |      The array flags cannot be set arbitrarily:
 |      
 |      - UPDATEIFCOPY can only be set ``False``.
 |      - WRITEBACKIFCOPY can only be set ``False``.
 |      - ALIGNED can only be set ``True`` if the data is truly aligned.
 |      - WRITEABLE can only be set ``True`` if the array owns its own memory
 |        or the ultimate owner of the memory exposes a writeable buffer
 |        interface or is a string.
 |      
 |      Arrays can be both C-style and Fortran-style contiguous simultaneously.
 |      This is clear for 1-dimensional arrays, but can also be true for higher
 |      dimensional arrays.
 |      
 |      Even for contiguous arrays a stride for a given dimension
 |      ``arr.strides[dim]`` may be *arbitrary* if ``arr.shape[dim] == 1``
 |      or the array has no elements.
 |      It does *not* generally hold that ``self.strides[-1] == self.itemsize``
 |      for C-style contiguous arrays or ``self.strides[0] == self.itemsize`` for
 |      Fortran-style contiguous arrays is true.
 |  
 |  flat
 |      A 1-D iterator over the array.
 |      
 |      This is a `numpy.flatiter` instance, which acts similarly to, but is not
 |      a subclass of, Python's built-in iterator object.
 |      
 |      See Also
 |      --------
 |      flatten : Return a copy of the array collapsed into one dimension.
 |      
 |      flatiter
 |      
 |      Examples
 |      --------
 |      >>> x = np.arange(1, 7).reshape(2, 3)
 |      >>> x
 |      array([[1, 2, 3],
 |             [4, 5, 6]])
 |      >>> x.flat[3]
 |      4
 |      >>> x.T
 |      array([[1, 4],
 |             [2, 5],
 |             [3, 6]])
 |      >>> x.T.flat[3]
 |      5
 |      >>> type(x.flat)
 |      <type 'numpy.flatiter'>
 |      
 |      An assignment example:
 |      
 |      >>> x.flat = 3; x
 |      array([[3, 3, 3],
 |             [3, 3, 3]])
 |      >>> x.flat[[1,4]] = 1; x
 |      array([[3, 1, 3],
 |             [3, 1, 3]])
 |  
 |  imag
 |      The imaginary part of the array.
 |      
 |      Examples
 |      --------
 |      >>> x = np.sqrt([1+0j, 0+1j])
 |      >>> x.imag
 |      array([ 0.        ,  0.70710678])
 |      >>> x.imag.dtype
 |      dtype('float64')
 |  
 |  itemsize
 |      Length of one array element in bytes.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1,2,3], dtype=np.float64)
 |      >>> x.itemsize
 |      8
 |      >>> x = np.array([1,2,3], dtype=np.complex128)
 |      >>> x.itemsize
 |      16
 |  
 |  nbytes
 |      Total bytes consumed by the elements of the array.
 |      
 |      Notes
 |      -----
 |      Does not include memory consumed by non-element attributes of the
 |      array object.
 |      
 |      Examples
 |      --------
 |      >>> x = np.zeros((3,5,2), dtype=np.complex128)
 |      >>> x.nbytes
 |      480
 |      >>> np.prod(x.shape) * x.itemsize
 |      480
 |  
 |  ndim
 |      Number of array dimensions.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 3])
 |      >>> x.ndim
 |      1
 |      >>> y = np.zeros((2, 3, 4))
 |      >>> y.ndim
 |      3
 |  
 |  real
 |      The real part of the array.
 |      
 |      Examples
 |      --------
 |      >>> x = np.sqrt([1+0j, 0+1j])
 |      >>> x.real
 |      array([ 1.        ,  0.70710678])
 |      >>> x.real.dtype
 |      dtype('float64')
 |      
 |      See Also
 |      --------
 |      numpy.real : equivalent function
 |  
 |  shape
 |      Tuple of array dimensions.
 |      
 |      The shape property is usually used to get the current shape of an array,
 |      but may also be used to reshape the array in-place by assigning a tuple of
 |      array dimensions to it.  As with `numpy.reshape`, one of the new shape
 |      dimensions can be -1, in which case its value is inferred from the size of
 |      the array and the remaining dimensions. Reshaping an array in-place will
 |      fail if a copy is required.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 3, 4])
 |      >>> x.shape
 |      (4,)
 |      >>> y = np.zeros((2, 3, 4))
 |      >>> y.shape
 |      (2, 3, 4)
 |      >>> y.shape = (3, 8)
 |      >>> y
 |      array([[ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
 |             [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
 |             [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.]])
 |      >>> y.shape = (3, 6)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: total size of new array must be unchanged
 |      >>> np.zeros((4,2))[::2].shape = (-1,)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      AttributeError: incompatible shape for a non-contiguous array
 |      
 |      See Also
 |      --------
 |      numpy.reshape : similar function
 |      ndarray.reshape : similar method
 |  
 |  size
 |      Number of elements in the array.
 |      
 |      Equivalent to ``np.prod(a.shape)``, i.e., the product of the array's
 |      dimensions.
 |      
 |      Examples
 |      --------
 |      >>> x = np.zeros((3, 5, 2), dtype=np.complex128)
 |      >>> x.size
 |      30
 |      >>> np.prod(x.shape)
 |      30
 |  
 |  strides
 |      Tuple of bytes to step in each dimension when traversing an array.
 |      
 |      The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a`
 |      is::
 |      
 |          offset = sum(np.array(i) * a.strides)
 |      
 |      A more detailed explanation of strides can be found in the
 |      ""ndarray.rst"" file in the NumPy reference guide.
 |      
 |      Notes
 |      -----
 |      Imagine an array of 32-bit integers (each 4 bytes)::
 |      
 |        x = np.array([[0, 1, 2, 3, 4],
 |                      [5, 6, 7, 8, 9]], dtype=np.int32)
 |      
 |      This array is stored in memory as 40 bytes, one after the other
 |      (known as a contiguous block of memory).  The strides of an array tell
 |      us how many bytes we have to skip in memory to move to the next position
 |      along a certain axis.  For example, we have to skip 4 bytes (1 value) to
 |      move to the next column, but 20 bytes (5 values) to get to the same
 |      position in the next row.  As such, the strides for the array `x` will be
 |      ``(20, 4)``.
 |      
 |      See Also
 |      --------
 |      numpy.lib.stride_tricks.as_strided
 |      
 |      Examples
 |      --------
 |      >>> y = np.reshape(np.arange(2*3*4), (2,3,4))
 |      >>> y
 |      array([[[ 0,  1,  2,  3],
 |              [ 4,  5,  6,  7],
 |              [ 8,  9, 10, 11]],
 |             [[12, 13, 14, 15],
 |              [16, 17, 18, 19],
 |              [20, 21, 22, 23]]])
 |      >>> y.strides
 |      (48, 16, 4)
 |      >>> y[1,1,1]
 |      17
 |      >>> offset=sum(y.strides * np.array((1,1,1)))
 |      >>> offset/y.itemsize
 |      17
 |      
 |      >>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0)
 |      >>> x.strides
 |      (32, 4, 224, 1344)
 |      >>> i = np.array([3,5,2,2])
 |      >>> offset = sum(i * x.strides)
 |      >>> x[3,5,2,2]
 |      813
 |      >>> offset / x.itemsize
 |      813
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from numpy.ndarray:
 |  
 |  __hash__ = None
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.matlab.mio5_params.MatlabOpaque,io.matlab.mio5_params,MatlabOpaque,"Python Library Documentation: class MatlabOpaque in module scipy.io.matlab.mio5_params

class MatlabOpaque(numpy.ndarray)
 |  Subclass to signal this is a matlab opaque matrix
 |  
 |  Method resolution order:
 |      MatlabOpaque
 |      numpy.ndarray
 |      builtins.object
 |  
 |  Static methods defined here:
 |  
 |  __new__(cls, input_array)
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from numpy.ndarray:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __array__(...)
 |      a.__array__(|dtype) -> reference if type unchanged, copy otherwise.
 |      
 |      Returns either a new reference to self if dtype is not given or a new array
 |      of provided data type if dtype is different from the current dtype of the
 |      array.
 |  
 |  __array_prepare__(...)
 |      a.__array_prepare__(obj) -> Object of same type as ndarray object obj.
 |  
 |  __array_ufunc__(...)
 |  
 |  __array_wrap__(...)
 |      a.__array_wrap__(obj) -> Object of same type as ndarray object a.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __complex__(...)
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __copy__(...)
 |      a.__copy__()
 |      
 |      Used if :func:`copy.copy` is called on an array. Returns a copy of the array.
 |      
 |      Equivalent to ``a.copy(order='K')``.
 |  
 |  __deepcopy__(...)
 |      a.__deepcopy__(memo, /) -> Deep copy of array.
 |      
 |      Used if :func:`copy.deepcopy` is called on an array.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __format__(...)
 |      default object formatter
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iadd__(self, value, /)
 |      Return self+=value.
 |  
 |  __iand__(self, value, /)
 |      Return self&=value.
 |  
 |  __ifloordiv__(self, value, /)
 |      Return self//=value.
 |  
 |  __ilshift__(self, value, /)
 |      Return self<<=value.
 |  
 |  __imatmul__(self, value, /)
 |      Return self@=value.
 |  
 |  __imod__(self, value, /)
 |      Return self%=value.
 |  
 |  __imul__(self, value, /)
 |      Return self*=value.
 |  
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __ior__(self, value, /)
 |      Return self|=value.
 |  
 |  __ipow__(self, value, /)
 |      Return self**=value.
 |  
 |  __irshift__(self, value, /)
 |      Return self>>=value.
 |  
 |  __isub__(self, value, /)
 |      Return self-=value.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __itruediv__(self, value, /)
 |      Return self/=value.
 |  
 |  __ixor__(self, value, /)
 |      Return self^=value.
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __matmul__(self, value, /)
 |      Return self@value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __reduce__(...)
 |      a.__reduce__()
 |      
 |      For pickling.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmatmul__(self, value, /)
 |      Return value@self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __setstate__(...)
 |      a.__setstate__(state, /)
 |      
 |      For unpickling.
 |      
 |      The `state` argument must be a sequence that contains the following
 |      elements:
 |      
 |      Parameters
 |      ----------
 |      version : int
 |          optional pickle version. If omitted defaults to 0.
 |      shape : tuple
 |      dtype : data-type
 |      isFortran : bool
 |      rawdata : string or list
 |          a binary string with the data (or a list if 'a' is an object array)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  all(...)
 |      a.all(axis=None, out=None, keepdims=False)
 |      
 |      Returns True if all elements evaluate to True.
 |      
 |      Refer to `numpy.all` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.all : equivalent function
 |  
 |  any(...)
 |      a.any(axis=None, out=None, keepdims=False)
 |      
 |      Returns True if any of the elements of `a` evaluate to True.
 |      
 |      Refer to `numpy.any` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.any : equivalent function
 |  
 |  argmax(...)
 |      a.argmax(axis=None, out=None)
 |      
 |      Return indices of the maximum values along the given axis.
 |      
 |      Refer to `numpy.argmax` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argmax : equivalent function
 |  
 |  argmin(...)
 |      a.argmin(axis=None, out=None)
 |      
 |      Return indices of the minimum values along the given axis of `a`.
 |      
 |      Refer to `numpy.argmin` for detailed documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argmin : equivalent function
 |  
 |  argpartition(...)
 |      a.argpartition(kth, axis=-1, kind='introselect', order=None)
 |      
 |      Returns the indices that would partition this array.
 |      
 |      Refer to `numpy.argpartition` for full documentation.
 |      
 |      .. versionadded:: 1.8.0
 |      
 |      See Also
 |      --------
 |      numpy.argpartition : equivalent function
 |  
 |  argsort(...)
 |      a.argsort(axis=-1, kind='quicksort', order=None)
 |      
 |      Returns the indices that would sort this array.
 |      
 |      Refer to `numpy.argsort` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argsort : equivalent function
 |  
 |  astype(...)
 |      a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)
 |      
 |      Copy of the array, cast to a specified type.
 |      
 |      Parameters
 |      ----------
 |      dtype : str or dtype
 |          Typecode or data-type to which the array is cast.
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          Controls the memory layout order of the result.
 |          'C' means C order, 'F' means Fortran order, 'A'
 |          means 'F' order if all the arrays are Fortran contiguous,
 |          'C' order otherwise, and 'K' means as close to the
 |          order the array elements appear in memory as possible.
 |          Default is 'K'.
 |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
 |          Controls what kind of data casting may occur. Defaults to 'unsafe'
 |          for backwards compatibility.
 |      
 |            * 'no' means the data types should not be cast at all.
 |            * 'equiv' means only byte-order changes are allowed.
 |            * 'safe' means only casts which can preserve values are allowed.
 |            * 'same_kind' means only safe casts or casts within a kind,
 |              like float64 to float32, are allowed.
 |            * 'unsafe' means any data conversions may be done.
 |      subok : bool, optional
 |          If True, then sub-classes will be passed-through (default), otherwise
 |          the returned array will be forced to be a base-class array.
 |      copy : bool, optional
 |          By default, astype always returns a newly allocated array. If this
 |          is set to false, and the `dtype`, `order`, and `subok`
 |          requirements are satisfied, the input array is returned instead
 |          of a copy.
 |      
 |      Returns
 |      -------
 |      arr_t : ndarray
 |          Unless `copy` is False and the other conditions for returning the input
 |          array are satisfied (see description for `copy` input parameter), `arr_t`
 |          is a new array of the same shape as the input array, with dtype, order
 |          given by `dtype`, `order`.
 |      
 |      Notes
 |      -----
 |      Starting in NumPy 1.9, astype method now returns an error if the string
 |      dtype to cast to is not long enough in 'safe' casting mode to hold the max
 |      value of integer/float array that is being casted. Previously the casting
 |      was allowed even if the result was truncated.
 |      
 |      Raises
 |      ------
 |      ComplexWarning
 |          When casting from complex to float or int. To avoid this,
 |          one should use ``a.real.astype(t)``.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 2.5])
 |      >>> x
 |      array([ 1. ,  2. ,  2.5])
 |      
 |      >>> x.astype(int)
 |      array([1, 2, 2])
 |  
 |  byteswap(...)
 |      a.byteswap(inplace=False)
 |      
 |      Swap the bytes of the array elements
 |      
 |      Toggle between low-endian and big-endian data representation by
 |      returning a byteswapped array, optionally swapped in-place.
 |      
 |      Parameters
 |      ----------
 |      inplace : bool, optional
 |          If ``True``, swap bytes in-place, default is ``False``.
 |      
 |      Returns
 |      -------
 |      out : ndarray
 |          The byteswapped array. If `inplace` is ``True``, this is
 |          a view to self.
 |      
 |      Examples
 |      --------
 |      >>> A = np.array([1, 256, 8755], dtype=np.int16)
 |      >>> map(hex, A)
 |      ['0x1', '0x100', '0x2233']
 |      >>> A.byteswap(inplace=True)
 |      array([  256,     1, 13090], dtype=int16)
 |      >>> map(hex, A)
 |      ['0x100', '0x1', '0x3322']
 |      
 |      Arrays of strings are not swapped
 |      
 |      >>> A = np.array(['ceg', 'fac'])
 |      >>> A.byteswap()
 |      array(['ceg', 'fac'],
 |            dtype='|S3')
 |  
 |  choose(...)
 |      a.choose(choices, out=None, mode='raise')
 |      
 |      Use an index array to construct a new array from a set of choices.
 |      
 |      Refer to `numpy.choose` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.choose : equivalent function
 |  
 |  clip(...)
 |      a.clip(min=None, max=None, out=None)
 |      
 |      Return an array whose values are limited to ``[min, max]``.
 |      One of max or min must be given.
 |      
 |      Refer to `numpy.clip` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.clip : equivalent function
 |  
 |  compress(...)
 |      a.compress(condition, axis=None, out=None)
 |      
 |      Return selected slices of this array along given axis.
 |      
 |      Refer to `numpy.compress` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.compress : equivalent function
 |  
 |  conj(...)
 |      a.conj()
 |      
 |      Complex-conjugate all elements.
 |      
 |      Refer to `numpy.conjugate` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.conjugate : equivalent function
 |  
 |  conjugate(...)
 |      a.conjugate()
 |      
 |      Return the complex conjugate, element-wise.
 |      
 |      Refer to `numpy.conjugate` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.conjugate : equivalent function
 |  
 |  copy(...)
 |      a.copy(order='C')
 |      
 |      Return a copy of the array.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          Controls the memory layout of the copy. 'C' means C-order,
 |          'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
 |          'C' otherwise. 'K' means match the layout of `a` as closely
 |          as possible. (Note that this function and :func:`numpy.copy` are very
 |          similar, but have different default values for their order=
 |          arguments.)
 |      
 |      See also
 |      --------
 |      numpy.copy
 |      numpy.copyto
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[1,2,3],[4,5,6]], order='F')
 |      
 |      >>> y = x.copy()
 |      
 |      >>> x.fill(0)
 |      
 |      >>> x
 |      array([[0, 0, 0],
 |             [0, 0, 0]])
 |      
 |      >>> y
 |      array([[1, 2, 3],
 |             [4, 5, 6]])
 |      
 |      >>> y.flags['C_CONTIGUOUS']
 |      True
 |  
 |  cumprod(...)
 |      a.cumprod(axis=None, dtype=None, out=None)
 |      
 |      Return the cumulative product of the elements along the given axis.
 |      
 |      Refer to `numpy.cumprod` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.cumprod : equivalent function
 |  
 |  cumsum(...)
 |      a.cumsum(axis=None, dtype=None, out=None)
 |      
 |      Return the cumulative sum of the elements along the given axis.
 |      
 |      Refer to `numpy.cumsum` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.cumsum : equivalent function
 |  
 |  diagonal(...)
 |      a.diagonal(offset=0, axis1=0, axis2=1)
 |      
 |      Return specified diagonals. In NumPy 1.9 the returned array is a
 |      read-only view instead of a copy as in previous NumPy versions.  In
 |      a future version the read-only restriction will be removed.
 |      
 |      Refer to :func:`numpy.diagonal` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.diagonal : equivalent function
 |  
 |  dot(...)
 |      a.dot(b, out=None)
 |      
 |      Dot product of two arrays.
 |      
 |      Refer to `numpy.dot` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.dot : equivalent function
 |      
 |      Examples
 |      --------
 |      >>> a = np.eye(2)
 |      >>> b = np.ones((2, 2)) * 2
 |      >>> a.dot(b)
 |      array([[ 2.,  2.],
 |             [ 2.,  2.]])
 |      
 |      This array method can be conveniently chained:
 |      
 |      >>> a.dot(b).dot(b)
 |      array([[ 8.,  8.],
 |             [ 8.,  8.]])
 |  
 |  dump(...)
 |      a.dump(file)
 |      
 |      Dump a pickle of the array to the specified file.
 |      The array can be read back with pickle.load or numpy.load.
 |      
 |      Parameters
 |      ----------
 |      file : str
 |          A string naming the dump file.
 |  
 |  dumps(...)
 |      a.dumps()
 |      
 |      Returns the pickle of the array as a string.
 |      pickle.loads or numpy.loads will convert the string back to an array.
 |      
 |      Parameters
 |      ----------
 |      None
 |  
 |  fill(...)
 |      a.fill(value)
 |      
 |      Fill the array with a scalar value.
 |      
 |      Parameters
 |      ----------
 |      value : scalar
 |          All elements of `a` will be assigned this value.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([1, 2])
 |      >>> a.fill(0)
 |      >>> a
 |      array([0, 0])
 |      >>> a = np.empty(2)
 |      >>> a.fill(1)
 |      >>> a
 |      array([ 1.,  1.])
 |  
 |  flatten(...)
 |      a.flatten(order='C')
 |      
 |      Return a copy of the array collapsed into one dimension.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          'C' means to flatten in row-major (C-style) order.
 |          'F' means to flatten in column-major (Fortran-
 |          style) order. 'A' means to flatten in column-major
 |          order if `a` is Fortran *contiguous* in memory,
 |          row-major order otherwise. 'K' means to flatten
 |          `a` in the order the elements occur in memory.
 |          The default is 'C'.
 |      
 |      Returns
 |      -------
 |      y : ndarray
 |          A copy of the input array, flattened to one dimension.
 |      
 |      See Also
 |      --------
 |      ravel : Return a flattened array.
 |      flat : A 1-D flat iterator over the array.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1,2], [3,4]])
 |      >>> a.flatten()
 |      array([1, 2, 3, 4])
 |      >>> a.flatten('F')
 |      array([1, 3, 2, 4])
 |  
 |  getfield(...)
 |      a.getfield(dtype, offset=0)
 |      
 |      Returns a field of the given array as a certain type.
 |      
 |      A field is a view of the array data with a given data-type. The values in
 |      the view are determined by the given type and the offset into the current
 |      array in bytes. The offset needs to be such that the view dtype fits in the
 |      array dtype; for example an array of dtype complex128 has 16-byte elements.
 |      If taking a view with a 32-bit integer (4 bytes), the offset needs to be
 |      between 0 and 12 bytes.
 |      
 |      Parameters
 |      ----------
 |      dtype : str or dtype
 |          The data type of the view. The dtype size of the view can not be larger
 |          than that of the array itself.
 |      offset : int
 |          Number of bytes to skip before beginning the element view.
 |      
 |      Examples
 |      --------
 |      >>> x = np.diag([1.+1.j]*2)
 |      >>> x[1, 1] = 2 + 4.j
 |      >>> x
 |      array([[ 1.+1.j,  0.+0.j],
 |             [ 0.+0.j,  2.+4.j]])
 |      >>> x.getfield(np.float64)
 |      array([[ 1.,  0.],
 |             [ 0.,  2.]])
 |      
 |      By choosing an offset of 8 bytes we can select the complex part of the
 |      array for our view:
 |      
 |      >>> x.getfield(np.float64, offset=8)
 |      array([[ 1.,  0.],
 |         [ 0.,  4.]])
 |  
 |  item(...)
 |      a.item(*args)
 |      
 |      Copy an element of an array to a standard Python scalar and return it.
 |      
 |      Parameters
 |      ----------
 |      \*args : Arguments (variable number and type)
 |      
 |          * none: in this case, the method only works for arrays
 |            with one element (`a.size == 1`), which element is
 |            copied into a standard Python scalar object and returned.
 |      
 |          * int_type: this argument is interpreted as a flat index into
 |            the array, specifying which element to copy and return.
 |      
 |          * tuple of int_types: functions as does a single int_type argument,
 |            except that the argument is interpreted as an nd-index into the
 |            array.
 |      
 |      Returns
 |      -------
 |      z : Standard Python scalar object
 |          A copy of the specified element of the array as a suitable
 |          Python scalar
 |      
 |      Notes
 |      -----
 |      When the data type of `a` is longdouble or clongdouble, item() returns
 |      a scalar array object because there is no available Python scalar that
 |      would not lose information. Void arrays return a buffer object for item(),
 |      unless fields are defined, in which case a tuple is returned.
 |      
 |      `item` is very similar to a[args], except, instead of an array scalar,
 |      a standard Python scalar is returned. This can be useful for speeding up
 |      access to elements of the array and doing arithmetic on elements of the
 |      array using Python's optimized math.
 |      
 |      Examples
 |      --------
 |      >>> x = np.random.randint(9, size=(3, 3))
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 8, 3],
 |             [8, 5, 3]])
 |      >>> x.item(3)
 |      2
 |      >>> x.item(7)
 |      5
 |      >>> x.item((0, 1))
 |      1
 |      >>> x.item((2, 2))
 |      3
 |  
 |  itemset(...)
 |      a.itemset(*args)
 |      
 |      Insert scalar into an array (scalar is cast to array's dtype, if possible)
 |      
 |      There must be at least 1 argument, and define the last argument
 |      as *item*.  Then, ``a.itemset(*args)`` is equivalent to but faster
 |      than ``a[args] = item``.  The item should be a scalar value and `args`
 |      must select a single item in the array `a`.
 |      
 |      Parameters
 |      ----------
 |      \*args : Arguments
 |          If one argument: a scalar, only used in case `a` is of size 1.
 |          If two arguments: the last argument is the value to be set
 |          and must be a scalar, the first argument specifies a single array
 |          element location. It is either an int or a tuple.
 |      
 |      Notes
 |      -----
 |      Compared to indexing syntax, `itemset` provides some speed increase
 |      for placing a scalar into a particular location in an `ndarray`,
 |      if you must do this.  However, generally this is discouraged:
 |      among other problems, it complicates the appearance of the code.
 |      Also, when using `itemset` (and `item`) inside a loop, be sure
 |      to assign the methods to a local variable to avoid the attribute
 |      look-up at each loop iteration.
 |      
 |      Examples
 |      --------
 |      >>> x = np.random.randint(9, size=(3, 3))
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 8, 3],
 |             [8, 5, 3]])
 |      >>> x.itemset(4, 0)
 |      >>> x.itemset((2, 2), 9)
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 0, 3],
 |             [8, 5, 9]])
 |  
 |  max(...)
 |      a.max(axis=None, out=None, keepdims=False)
 |      
 |      Return the maximum along a given axis.
 |      
 |      Refer to `numpy.amax` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.amax : equivalent function
 |  
 |  mean(...)
 |      a.mean(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Returns the average of the array elements along given axis.
 |      
 |      Refer to `numpy.mean` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.mean : equivalent function
 |  
 |  min(...)
 |      a.min(axis=None, out=None, keepdims=False)
 |      
 |      Return the minimum along a given axis.
 |      
 |      Refer to `numpy.amin` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.amin : equivalent function
 |  
 |  newbyteorder(...)
 |      arr.newbyteorder(new_order='S')
 |      
 |      Return the array with the same data viewed with a different byte order.
 |      
 |      Equivalent to::
 |      
 |          arr.view(arr.dtype.newbytorder(new_order))
 |      
 |      Changes are also made in all fields and sub-arrays of the array data
 |      type.
 |      
 |      
 |      
 |      Parameters
 |      ----------
 |      new_order : string, optional
 |          Byte order to force; a value from the byte order specifications
 |          below. `new_order` codes can be any of:
 |      
 |          * 'S' - swap dtype from current to opposite endian
 |          * {'<', 'L'} - little endian
 |          * {'>', 'B'} - big endian
 |          * {'=', 'N'} - native order
 |          * {'|', 'I'} - ignore (no change to byte order)
 |      
 |          The default value ('S') results in swapping the current
 |          byte order. The code does a case-insensitive check on the first
 |          letter of `new_order` for the alternatives above.  For example,
 |          any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 |      
 |      
 |      Returns
 |      -------
 |      new_arr : array
 |          New array object with the dtype reflecting given change to the
 |          byte order.
 |  
 |  nonzero(...)
 |      a.nonzero()
 |      
 |      Return the indices of the elements that are non-zero.
 |      
 |      Refer to `numpy.nonzero` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.nonzero : equivalent function
 |  
 |  partition(...)
 |      a.partition(kth, axis=-1, kind='introselect', order=None)
 |      
 |      Rearranges the elements in the array in such a way that value of the
 |      element in kth position is in the position it would be in a sorted array.
 |      All elements smaller than the kth element are moved before this element and
 |      all equal or greater are moved behind it. The ordering of the elements in
 |      the two partitions is undefined.
 |      
 |      .. versionadded:: 1.8.0
 |      
 |      Parameters
 |      ----------
 |      kth : int or sequence of ints
 |          Element index to partition by. The kth element value will be in its
 |          final sorted position and all smaller elements will be moved before it
 |          and all equal or greater elements behind it.
 |          The order all elements in the partitions is undefined.
 |          If provided with a sequence of kth it will partition all elements
 |          indexed by kth of them into their sorted position at once.
 |      axis : int, optional
 |          Axis along which to sort. Default is -1, which means sort along the
 |          last axis.
 |      kind : {'introselect'}, optional
 |          Selection algorithm. Default is 'introselect'.
 |      order : str or list of str, optional
 |          When `a` is an array with fields defined, this argument specifies
 |          which fields to compare first, second, etc.  A single field can
 |          be specified as a string, and not all fields need be specified,
 |          but unspecified fields will still be used, in the order in which
 |          they come up in the dtype, to break ties.
 |      
 |      See Also
 |      --------
 |      numpy.partition : Return a parititioned copy of an array.
 |      argpartition : Indirect partition.
 |      sort : Full sort.
 |      
 |      Notes
 |      -----
 |      See ``np.partition`` for notes on the different algorithms.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([3, 4, 2, 1])
 |      >>> a.partition(3)
 |      >>> a
 |      array([2, 1, 3, 4])
 |      
 |      >>> a.partition((1, 3))
 |      array([1, 2, 3, 4])
 |  
 |  prod(...)
 |      a.prod(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Return the product of the array elements over the given axis
 |      
 |      Refer to `numpy.prod` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.prod : equivalent function
 |  
 |  ptp(...)
 |      a.ptp(axis=None, out=None)
 |      
 |      Peak to peak (maximum - minimum) value along a given axis.
 |      
 |      Refer to `numpy.ptp` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.ptp : equivalent function
 |  
 |  put(...)
 |      a.put(indices, values, mode='raise')
 |      
 |      Set ``a.flat[n] = values[n]`` for all `n` in indices.
 |      
 |      Refer to `numpy.put` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.put : equivalent function
 |  
 |  ravel(...)
 |      a.ravel([order])
 |      
 |      Return a flattened array.
 |      
 |      Refer to `numpy.ravel` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.ravel : equivalent function
 |      
 |      ndarray.flat : a flat iterator on the array.
 |  
 |  repeat(...)
 |      a.repeat(repeats, axis=None)
 |      
 |      Repeat elements of an array.
 |      
 |      Refer to `numpy.repeat` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.repeat : equivalent function
 |  
 |  reshape(...)
 |      a.reshape(shape, order='C')
 |      
 |      Returns an array containing the same data with a new shape.
 |      
 |      Refer to `numpy.reshape` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.reshape : equivalent function
 |      
 |      Notes
 |      -----
 |      Unlike the free function `numpy.reshape`, this method on `ndarray` allows
 |      the elements of the shape parameter to be passed in as separate arguments.
 |      For example, ``a.reshape(10, 11)`` is equivalent to
 |      ``a.reshape((10, 11))``.
 |  
 |  resize(...)
 |      a.resize(new_shape, refcheck=True)
 |      
 |      Change shape and size of array in-place.
 |      
 |      Parameters
 |      ----------
 |      new_shape : tuple of ints, or `n` ints
 |          Shape of resized array.
 |      refcheck : bool, optional
 |          If False, reference count will not be checked. Default is True.
 |      
 |      Returns
 |      -------
 |      None
 |      
 |      Raises
 |      ------
 |      ValueError
 |          If `a` does not own its own data or references or views to it exist,
 |          and the data memory must be changed.
 |          PyPy only: will always raise if the data memory must be changed, since
 |          there is no reliable way to determine if references or views to it
 |          exist.
 |      
 |      SystemError
 |          If the `order` keyword argument is specified. This behaviour is a
 |          bug in NumPy.
 |      
 |      See Also
 |      --------
 |      resize : Return a new array with the specified shape.
 |      
 |      Notes
 |      -----
 |      This reallocates space for the data area if necessary.
 |      
 |      Only contiguous arrays (data elements consecutive in memory) can be
 |      resized.
 |      
 |      The purpose of the reference count check is to make sure you
 |      do not use this array as a buffer for another Python object and then
 |      reallocate the memory. However, reference counts can increase in
 |      other ways so if you are sure that you have not shared the memory
 |      for this array with another Python object, then you may safely set
 |      `refcheck` to False.
 |      
 |      Examples
 |      --------
 |      Shrinking an array: array is flattened (in the order that the data are
 |      stored in memory), resized, and reshaped:
 |      
 |      >>> a = np.array([[0, 1], [2, 3]], order='C')
 |      >>> a.resize((2, 1))
 |      >>> a
 |      array([[0],
 |             [1]])
 |      
 |      >>> a = np.array([[0, 1], [2, 3]], order='F')
 |      >>> a.resize((2, 1))
 |      >>> a
 |      array([[0],
 |             [2]])
 |      
 |      Enlarging an array: as above, but missing entries are filled with zeros:
 |      
 |      >>> b = np.array([[0, 1], [2, 3]])
 |      >>> b.resize(2, 3) # new_shape parameter doesn't have to be a tuple
 |      >>> b
 |      array([[0, 1, 2],
 |             [3, 0, 0]])
 |      
 |      Referencing an array prevents resizing...
 |      
 |      >>> c = a
 |      >>> a.resize((1, 1))
 |      Traceback (most recent call last):
 |      ...
 |      ValueError: cannot resize an array that has been referenced ...
 |      
 |      Unless `refcheck` is False:
 |      
 |      >>> a.resize((1, 1), refcheck=False)
 |      >>> a
 |      array([[0]])
 |      >>> c
 |      array([[0]])
 |  
 |  round(...)
 |      a.round(decimals=0, out=None)
 |      
 |      Return `a` with each element rounded to the given number of decimals.
 |      
 |      Refer to `numpy.around` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.around : equivalent function
 |  
 |  searchsorted(...)
 |      a.searchsorted(v, side='left', sorter=None)
 |      
 |      Find indices where elements of v should be inserted in a to maintain order.
 |      
 |      For full documentation, see `numpy.searchsorted`
 |      
 |      See Also
 |      --------
 |      numpy.searchsorted : equivalent function
 |  
 |  setfield(...)
 |      a.setfield(val, dtype, offset=0)
 |      
 |      Put a value into a specified place in a field defined by a data-type.
 |      
 |      Place `val` into `a`'s field defined by `dtype` and beginning `offset`
 |      bytes into the field.
 |      
 |      Parameters
 |      ----------
 |      val : object
 |          Value to be placed in field.
 |      dtype : dtype object
 |          Data-type of the field in which to place `val`.
 |      offset : int, optional
 |          The number of bytes into the field at which to place `val`.
 |      
 |      Returns
 |      -------
 |      None
 |      
 |      See Also
 |      --------
 |      getfield
 |      
 |      Examples
 |      --------
 |      >>> x = np.eye(3)
 |      >>> x.getfield(np.float64)
 |      array([[ 1.,  0.,  0.],
 |             [ 0.,  1.,  0.],
 |             [ 0.,  0.,  1.]])
 |      >>> x.setfield(3, np.int32)
 |      >>> x.getfield(np.int32)
 |      array([[3, 3, 3],
 |             [3, 3, 3],
 |             [3, 3, 3]])
 |      >>> x
 |      array([[  1.00000000e+000,   1.48219694e-323,   1.48219694e-323],
 |             [  1.48219694e-323,   1.00000000e+000,   1.48219694e-323],
 |             [  1.48219694e-323,   1.48219694e-323,   1.00000000e+000]])
 |      >>> x.setfield(np.eye(3), np.int32)
 |      >>> x
 |      array([[ 1.,  0.,  0.],
 |             [ 0.,  1.,  0.],
 |             [ 0.,  0.,  1.]])
 |  
 |  setflags(...)
 |      a.setflags(write=None, align=None, uic=None)
 |      
 |      Set array flags WRITEABLE, ALIGNED, (WRITEBACKIFCOPY and UPDATEIFCOPY),
 |      respectively.
 |      
 |      These Boolean-valued flags affect how numpy interprets the memory
 |      area used by `a` (see Notes below). The ALIGNED flag can only
 |      be set to True if the data is actually aligned according to the type.
 |      The WRITEBACKIFCOPY and (deprecated) UPDATEIFCOPY flags can never be set
 |      to True. The flag WRITEABLE can only be set to True if the array owns its
 |      own memory, or the ultimate owner of the memory exposes a writeable buffer
 |      interface, or is a string. (The exception for string is made so that
 |      unpickling can be done without copying memory.)
 |      
 |      Parameters
 |      ----------
 |      write : bool, optional
 |          Describes whether or not `a` can be written to.
 |      align : bool, optional
 |          Describes whether or not `a` is aligned properly for its type.
 |      uic : bool, optional
 |          Describes whether or not `a` is a copy of another ""base"" array.
 |      
 |      Notes
 |      -----
 |      Array flags provide information about how the memory area used
 |      for the array is to be interpreted. There are 7 Boolean flags
 |      in use, only four of which can be changed by the user:
 |      WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED.
 |      
 |      WRITEABLE (W) the data area can be written to;
 |      
 |      ALIGNED (A) the data and strides are aligned appropriately for the hardware
 |      (as determined by the compiler);
 |      
 |      UPDATEIFCOPY (U) (deprecated), replaced by WRITEBACKIFCOPY;
 |      
 |      WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced
 |      by .base). When the C-API function PyArray_ResolveWritebackIfCopy is
 |      called, the base array will be updated with the contents of this array.
 |      
 |      All flags can be accessed using the single (upper case) letter as well
 |      as the full name.
 |      
 |      Examples
 |      --------
 |      >>> y
 |      array([[3, 1, 7],
 |             [2, 0, 0],
 |             [8, 5, 9]])
 |      >>> y.flags
 |        C_CONTIGUOUS : True
 |        F_CONTIGUOUS : False
 |        OWNDATA : True
 |        WRITEABLE : True
 |        ALIGNED : True
 |        WRITEBACKIFCOPY : False
 |        UPDATEIFCOPY : False
 |      >>> y.setflags(write=0, align=0)
 |      >>> y.flags
 |        C_CONTIGUOUS : True
 |        F_CONTIGUOUS : False
 |        OWNDATA : True
 |        WRITEABLE : False
 |        ALIGNED : False
 |        WRITEBACKIFCOPY : False
 |        UPDATEIFCOPY : False
 |      >>> y.setflags(uic=1)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: cannot set WRITEBACKIFCOPY flag to True
 |  
 |  sort(...)
 |      a.sort(axis=-1, kind='quicksort', order=None)
 |      
 |      Sort an array, in-place.
 |      
 |      Parameters
 |      ----------
 |      axis : int, optional
 |          Axis along which to sort. Default is -1, which means sort along the
 |          last axis.
 |      kind : {'quicksort', 'mergesort', 'heapsort'}, optional
 |          Sorting algorithm. Default is 'quicksort'.
 |      order : str or list of str, optional
 |          When `a` is an array with fields defined, this argument specifies
 |          which fields to compare first, second, etc.  A single field can
 |          be specified as a string, and not all fields need be specified,
 |          but unspecified fields will still be used, in the order in which
 |          they come up in the dtype, to break ties.
 |      
 |      See Also
 |      --------
 |      numpy.sort : Return a sorted copy of an array.
 |      argsort : Indirect sort.
 |      lexsort : Indirect stable sort on multiple keys.
 |      searchsorted : Find elements in sorted array.
 |      partition: Partial sort.
 |      
 |      Notes
 |      -----
 |      See ``sort`` for notes on the different sorting algorithms.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1,4], [3,1]])
 |      >>> a.sort(axis=1)
 |      >>> a
 |      array([[1, 4],
 |             [1, 3]])
 |      >>> a.sort(axis=0)
 |      >>> a
 |      array([[1, 3],
 |             [1, 4]])
 |      
 |      Use the `order` keyword to specify a field to use when sorting a
 |      structured array:
 |      
 |      >>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])
 |      >>> a.sort(order='y')
 |      >>> a
 |      array([('c', 1), ('a', 2)],
 |            dtype=[('x', '|S1'), ('y', '<i4')])
 |  
 |  squeeze(...)
 |      a.squeeze(axis=None)
 |      
 |      Remove single-dimensional entries from the shape of `a`.
 |      
 |      Refer to `numpy.squeeze` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.squeeze : equivalent function
 |  
 |  std(...)
 |      a.std(axis=None, dtype=None, out=None, ddof=0, keepdims=False)
 |      
 |      Returns the standard deviation of the array elements along given axis.
 |      
 |      Refer to `numpy.std` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.std : equivalent function
 |  
 |  sum(...)
 |      a.sum(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Return the sum of the array elements over the given axis.
 |      
 |      Refer to `numpy.sum` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.sum : equivalent function
 |  
 |  swapaxes(...)
 |      a.swapaxes(axis1, axis2)
 |      
 |      Return a view of the array with `axis1` and `axis2` interchanged.
 |      
 |      Refer to `numpy.swapaxes` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.swapaxes : equivalent function
 |  
 |  take(...)
 |      a.take(indices, axis=None, out=None, mode='raise')
 |      
 |      Return an array formed from the elements of `a` at the given indices.
 |      
 |      Refer to `numpy.take` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.take : equivalent function
 |  
 |  tobytes(...)
 |      a.tobytes(order='C')
 |      
 |      Construct Python bytes containing the raw data bytes in the array.
 |      
 |      Constructs Python bytes showing a copy of the raw contents of
 |      data memory. The bytes object can be produced in either 'C' or 'Fortran',
 |      or 'Any' order (the default is 'C'-order). 'Any' order means C-order
 |      unless the F_CONTIGUOUS flag in the array is set, in which case it
 |      means 'Fortran' order.
 |      
 |      .. versionadded:: 1.9.0
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', None}, optional
 |          Order of the data for multidimensional arrays:
 |          C, Fortran, or the same as for the original array.
 |      
 |      Returns
 |      -------
 |      s : bytes
 |          Python bytes exhibiting a copy of `a`'s raw data.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[0, 1], [2, 3]])
 |      >>> x.tobytes()
 |      b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
 |      >>> x.tobytes('C') == x.tobytes()
 |      True
 |      >>> x.tobytes('F')
 |      b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
 |  
 |  tofile(...)
 |      a.tofile(fid, sep="""", format=""%s"")
 |      
 |      Write array to a file as text or binary (default).
 |      
 |      Data is always written in 'C' order, independent of the order of `a`.
 |      The data produced by this method can be recovered using the function
 |      fromfile().
 |      
 |      Parameters
 |      ----------
 |      fid : file or str
 |          An open file object, or a string containing a filename.
 |      sep : str
 |          Separator between array items for text output.
 |          If """" (empty), a binary file is written, equivalent to
 |          ``file.write(a.tobytes())``.
 |      format : str
 |          Format string for text file output.
 |          Each entry in the array is formatted to text by first converting
 |          it to the closest Python type, and then using ""format"" % item.
 |      
 |      Notes
 |      -----
 |      This is a convenience function for quick storage of array data.
 |      Information on endianness and precision is lost, so this method is not a
 |      good choice for files intended to archive data or transport data between
 |      machines with different endianness. Some of these problems can be overcome
 |      by outputting the data as text files, at the expense of speed and file
 |      size.
 |  
 |  tolist(...)
 |      a.tolist()
 |      
 |      Return the array as a (possibly nested) list.
 |      
 |      Return a copy of the array data as a (nested) Python list.
 |      Data items are converted to the nearest compatible Python type.
 |      
 |      Parameters
 |      ----------
 |      none
 |      
 |      Returns
 |      -------
 |      y : list
 |          The possibly nested list of array elements.
 |      
 |      Notes
 |      -----
 |      The array may be recreated, ``a = np.array(a.tolist())``.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([1, 2])
 |      >>> a.tolist()
 |      [1, 2]
 |      >>> a = np.array([[1, 2], [3, 4]])
 |      >>> list(a)
 |      [array([1, 2]), array([3, 4])]
 |      >>> a.tolist()
 |      [[1, 2], [3, 4]]
 |  
 |  tostring(...)
 |      a.tostring(order='C')
 |      
 |      Construct Python bytes containing the raw data bytes in the array.
 |      
 |      Constructs Python bytes showing a copy of the raw contents of
 |      data memory. The bytes object can be produced in either 'C' or 'Fortran',
 |      or 'Any' order (the default is 'C'-order). 'Any' order means C-order
 |      unless the F_CONTIGUOUS flag in the array is set, in which case it
 |      means 'Fortran' order.
 |      
 |      This function is a compatibility alias for tobytes. Despite its name it returns bytes not strings.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', None}, optional
 |          Order of the data for multidimensional arrays:
 |          C, Fortran, or the same as for the original array.
 |      
 |      Returns
 |      -------
 |      s : bytes
 |          Python bytes exhibiting a copy of `a`'s raw data.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[0, 1], [2, 3]])
 |      >>> x.tobytes()
 |      b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
 |      >>> x.tobytes('C') == x.tobytes()
 |      True
 |      >>> x.tobytes('F')
 |      b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
 |  
 |  trace(...)
 |      a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)
 |      
 |      Return the sum along diagonals of the array.
 |      
 |      Refer to `numpy.trace` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.trace : equivalent function
 |  
 |  transpose(...)
 |      a.transpose(*axes)
 |      
 |      Returns a view of the array with axes transposed.
 |      
 |      For a 1-D array, this has no effect. (To change between column and
 |      row vectors, first cast the 1-D array into a matrix object.)
 |      For a 2-D array, this is the usual matrix transpose.
 |      For an n-D array, if axes are given, their order indicates how the
 |      axes are permuted (see Examples). If axes are not provided and
 |      ``a.shape = (i[0], i[1], ... i[n-2], i[n-1])``, then
 |      ``a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0])``.
 |      
 |      Parameters
 |      ----------
 |      axes : None, tuple of ints, or `n` ints
 |      
 |       * None or no argument: reverses the order of the axes.
 |      
 |       * tuple of ints: `i` in the `j`-th place in the tuple means `a`'s
 |         `i`-th axis becomes `a.transpose()`'s `j`-th axis.
 |      
 |       * `n` ints: same as an n-tuple of the same ints (this form is
 |         intended simply as a ""convenience"" alternative to the tuple form)
 |      
 |      Returns
 |      -------
 |      out : ndarray
 |          View of `a`, with axes suitably permuted.
 |      
 |      See Also
 |      --------
 |      ndarray.T : Array property returning the array transposed.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1, 2], [3, 4]])
 |      >>> a
 |      array([[1, 2],
 |             [3, 4]])
 |      >>> a.transpose()
 |      array([[1, 3],
 |             [2, 4]])
 |      >>> a.transpose((1, 0))
 |      array([[1, 3],
 |             [2, 4]])
 |      >>> a.transpose(1, 0)
 |      array([[1, 3],
 |             [2, 4]])
 |  
 |  var(...)
 |      a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False)
 |      
 |      Returns the variance of the array elements, along given axis.
 |      
 |      Refer to `numpy.var` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.var : equivalent function
 |  
 |  view(...)
 |      a.view(dtype=None, type=None)
 |      
 |      New view of array with the same data.
 |      
 |      Parameters
 |      ----------
 |      dtype : data-type or ndarray sub-class, optional
 |          Data-type descriptor of the returned view, e.g., float32 or int16. The
 |          default, None, results in the view having the same data-type as `a`.
 |          This argument can also be specified as an ndarray sub-class, which
 |          then specifies the type of the returned object (this is equivalent to
 |          setting the ``type`` parameter).
 |      type : Python type, optional
 |          Type of the returned view, e.g., ndarray or matrix.  Again, the
 |          default None results in type preservation.
 |      
 |      Notes
 |      -----
 |      ``a.view()`` is used two different ways:
 |      
 |      ``a.view(some_dtype)`` or ``a.view(dtype=some_dtype)`` constructs a view
 |      of the array's memory with a different data-type.  This can cause a
 |      reinterpretation of the bytes of memory.
 |      
 |      ``a.view(ndarray_subclass)`` or ``a.view(type=ndarray_subclass)`` just
 |      returns an instance of `ndarray_subclass` that looks at the same array
 |      (same shape, dtype, etc.)  This does not cause a reinterpretation of the
 |      memory.
 |      
 |      For ``a.view(some_dtype)``, if ``some_dtype`` has a different number of
 |      bytes per entry than the previous dtype (for example, converting a
 |      regular array to a structured array), then the behavior of the view
 |      cannot be predicted just from the superficial appearance of ``a`` (shown
 |      by ``print(a)``). It also depends on exactly how ``a`` is stored in
 |      memory. Therefore if ``a`` is C-ordered versus fortran-ordered, versus
 |      defined as a slice or transpose, etc., the view may give different
 |      results.
 |      
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])
 |      
 |      Viewing array data using a different type and dtype:
 |      
 |      >>> y = x.view(dtype=np.int16, type=np.matrix)
 |      >>> y
 |      matrix([[513]], dtype=int16)
 |      >>> print(type(y))
 |      <class 'numpy.matrixlib.defmatrix.matrix'>
 |      
 |      Creating a view on a structured array so it can be used in calculations
 |      
 |      >>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)])
 |      >>> xv = x.view(dtype=np.int8).reshape(-1,2)
 |      >>> xv
 |      array([[1, 2],
 |             [3, 4]], dtype=int8)
 |      >>> xv.mean(0)
 |      array([ 2.,  3.])
 |      
 |      Making changes to the view changes the underlying array
 |      
 |      >>> xv[0,1] = 20
 |      >>> print(x)
 |      [(1, 20) (3, 4)]
 |      
 |      Using a view to convert an array to a recarray:
 |      
 |      >>> z = x.view(np.recarray)
 |      >>> z.a
 |      array([1], dtype=int8)
 |      
 |      Views share data:
 |      
 |      >>> x[0] = (9, 10)
 |      >>> z[0]
 |      (9, 10)
 |      
 |      Views that change the dtype size (bytes per entry) should normally be
 |      avoided on arrays defined by slices, transposes, fortran-ordering, etc.:
 |      
 |      >>> x = np.array([[1,2,3],[4,5,6]], dtype=np.int16)
 |      >>> y = x[:, 0:2]
 |      >>> y
 |      array([[1, 2],
 |             [4, 5]], dtype=int16)
 |      >>> y.view(dtype=[('width', np.int16), ('length', np.int16)])
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: new type not compatible with array.
 |      >>> z = y.copy()
 |      >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
 |      array([[(1, 2)],
 |             [(4, 5)]], dtype=[('width', '<i2'), ('length', '<i2')])
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from numpy.ndarray:
 |  
 |  T
 |      Same as self.transpose(), except that self is returned if
 |      self.ndim < 2.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[1.,2.],[3.,4.]])
 |      >>> x
 |      array([[ 1.,  2.],
 |             [ 3.,  4.]])
 |      >>> x.T
 |      array([[ 1.,  3.],
 |             [ 2.,  4.]])
 |      >>> x = np.array([1.,2.,3.,4.])
 |      >>> x
 |      array([ 1.,  2.,  3.,  4.])
 |      >>> x.T
 |      array([ 1.,  2.,  3.,  4.])
 |  
 |  __array_finalize__
 |      None.
 |  
 |  __array_interface__
 |      Array protocol: Python side.
 |  
 |  __array_priority__
 |      Array priority.
 |  
 |  __array_struct__
 |      Array protocol: C-struct side.
 |  
 |  base
 |      Base object if memory is from some other object.
 |      
 |      Examples
 |      --------
 |      The base of an array that owns its memory is None:
 |      
 |      >>> x = np.array([1,2,3,4])
 |      >>> x.base is None
 |      True
 |      
 |      Slicing creates a view, whose memory is shared with x:
 |      
 |      >>> y = x[2:]
 |      >>> y.base is x
 |      True
 |  
 |  ctypes
 |      An object to simplify the interaction of the array with the ctypes
 |      module.
 |      
 |      This attribute creates an object that makes it easier to use arrays
 |      when calling shared libraries with the ctypes module. The returned
 |      object has, among others, data, shape, and strides attributes (see
 |      Notes below) which themselves return ctypes objects that can be used
 |      as arguments to a shared library.
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      c : Python object
 |          Possessing attributes data, shape, strides, etc.
 |      
 |      See Also
 |      --------
 |      numpy.ctypeslib
 |      
 |      Notes
 |      -----
 |      Below are the public attributes of this object which were documented
 |      in ""Guide to NumPy"" (we have omitted undocumented public attributes,
 |      as well as documented private attributes):
 |      
 |      * data: A pointer to the memory area of the array as a Python integer.
 |        This memory area may contain data that is not aligned, or not in correct
 |        byte-order. The memory area may not even be writeable. The array
 |        flags and data-type of this array should be respected when passing this
 |        attribute to arbitrary C-code to avoid trouble that can include Python
 |        crashing. User Beware! The value of this attribute is exactly the same
 |        as self._array_interface_['data'][0].
 |      
 |      * shape (c_intp*self.ndim): A ctypes array of length self.ndim where
 |        the basetype is the C-integer corresponding to dtype('p') on this
 |        platform. This base-type could be c_int, c_long, or c_longlong
 |        depending on the platform. The c_intp type is defined accordingly in
 |        numpy.ctypeslib. The ctypes array contains the shape of the underlying
 |        array.
 |      
 |      * strides (c_intp*self.ndim): A ctypes array of length self.ndim where
 |        the basetype is the same as for the shape attribute. This ctypes array
 |        contains the strides information from the underlying array. This strides
 |        information is important for showing how many bytes must be jumped to
 |        get to the next element in the array.
 |      
 |      * data_as(obj): Return the data pointer cast to a particular c-types object.
 |        For example, calling self._as_parameter_ is equivalent to
 |        self.data_as(ctypes.c_void_p). Perhaps you want to use the data as a
 |        pointer to a ctypes array of floating-point data:
 |        self.data_as(ctypes.POINTER(ctypes.c_double)).
 |      
 |      * shape_as(obj): Return the shape tuple as an array of some other c-types
 |        type. For example: self.shape_as(ctypes.c_short).
 |      
 |      * strides_as(obj): Return the strides tuple as an array of some other
 |        c-types type. For example: self.strides_as(ctypes.c_longlong).
 |      
 |      Be careful using the ctypes attribute - especially on temporary
 |      arrays or arrays constructed on the fly. For example, calling
 |      ``(a+b).ctypes.data_as(ctypes.c_void_p)`` returns a pointer to memory
 |      that is invalid because the array created as (a+b) is deallocated
 |      before the next Python statement. You can avoid this problem using
 |      either ``c=a+b`` or ``ct=(a+b).ctypes``. In the latter case, ct will
 |      hold a reference to the array until ct is deleted or re-assigned.
 |      
 |      If the ctypes module is not available, then the ctypes attribute
 |      of array objects still returns something useful, but ctypes objects
 |      are not returned and errors may be raised instead. In particular,
 |      the object will still have the as parameter attribute which will
 |      return an integer equal to the data attribute.
 |      
 |      Examples
 |      --------
 |      >>> import ctypes
 |      >>> x
 |      array([[0, 1],
 |             [2, 3]])
 |      >>> x.ctypes.data
 |      30439712
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long))
 |      <ctypes.LP_c_long object at 0x01F01300>
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)).contents
 |      c_long(0)
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_longlong)).contents
 |      c_longlong(4294967296L)
 |      >>> x.ctypes.shape
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FFD580>
 |      >>> x.ctypes.shape_as(ctypes.c_long)
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
 |      >>> x.ctypes.strides
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
 |      >>> x.ctypes.strides_as(ctypes.c_longlong)
 |      <numpy.core._internal.c_longlong_Array_2 object at 0x01F01300>
 |  
 |  data
 |      Python buffer object pointing to the start of the array's data.
 |  
 |  dtype
 |      Data-type of the array's elements.
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      d : numpy dtype object
 |      
 |      See Also
 |      --------
 |      numpy.dtype
 |      
 |      Examples
 |      --------
 |      >>> x
 |      array([[0, 1],
 |             [2, 3]])
 |      >>> x.dtype
 |      dtype('int32')
 |      >>> type(x.dtype)
 |      <type 'numpy.dtype'>
 |  
 |  flags
 |      Information about the memory layout of the array.
 |      
 |      Attributes
 |      ----------
 |      C_CONTIGUOUS (C)
 |          The data is in a single, C-style contiguous segment.
 |      F_CONTIGUOUS (F)
 |          The data is in a single, Fortran-style contiguous segment.
 |      OWNDATA (O)
 |          The array owns the memory it uses or borrows it from another object.
 |      WRITEABLE (W)
 |          The data area can be written to.  Setting this to False locks
 |          the data, making it read-only.  A view (slice, etc.) inherits WRITEABLE
 |          from its base array at creation time, but a view of a writeable
 |          array may be subsequently locked while the base array remains writeable.
 |          (The opposite is not true, in that a view of a locked array may not
 |          be made writeable.  However, currently, locking a base object does not
 |          lock any views that already reference it, so under that circumstance it
 |          is possible to alter the contents of a locked array via a previously
 |          created writeable view onto it.)  Attempting to change a non-writeable
 |          array raises a RuntimeError exception.
 |      ALIGNED (A)
 |          The data and all elements are aligned appropriately for the hardware.
 |      WRITEBACKIFCOPY (X)
 |          This array is a copy of some other array. The C-API function
 |          PyArray_ResolveWritebackIfCopy must be called before deallocating
 |          to the base array will be updated with the contents of this array.
 |      UPDATEIFCOPY (U)
 |          (Deprecated, use WRITEBACKIFCOPY) This array is a copy of some other array.
 |          When this array is
 |          deallocated, the base array will be updated with the contents of
 |          this array.
 |      FNC
 |          F_CONTIGUOUS and not C_CONTIGUOUS.
 |      FORC
 |          F_CONTIGUOUS or C_CONTIGUOUS (one-segment test).
 |      BEHAVED (B)
 |          ALIGNED and WRITEABLE.
 |      CARRAY (CA)
 |          BEHAVED and C_CONTIGUOUS.
 |      FARRAY (FA)
 |          BEHAVED and F_CONTIGUOUS and not C_CONTIGUOUS.
 |      
 |      Notes
 |      -----
 |      The `flags` object can be accessed dictionary-like (as in ``a.flags['WRITEABLE']``),
 |      or by using lowercased attribute names (as in ``a.flags.writeable``). Short flag
 |      names are only supported in dictionary access.
 |      
 |      Only the WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED flags can be
 |      changed by the user, via direct assignment to the attribute or dictionary
 |      entry, or by calling `ndarray.setflags`.
 |      
 |      The array flags cannot be set arbitrarily:
 |      
 |      - UPDATEIFCOPY can only be set ``False``.
 |      - WRITEBACKIFCOPY can only be set ``False``.
 |      - ALIGNED can only be set ``True`` if the data is truly aligned.
 |      - WRITEABLE can only be set ``True`` if the array owns its own memory
 |        or the ultimate owner of the memory exposes a writeable buffer
 |        interface or is a string.
 |      
 |      Arrays can be both C-style and Fortran-style contiguous simultaneously.
 |      This is clear for 1-dimensional arrays, but can also be true for higher
 |      dimensional arrays.
 |      
 |      Even for contiguous arrays a stride for a given dimension
 |      ``arr.strides[dim]`` may be *arbitrary* if ``arr.shape[dim] == 1``
 |      or the array has no elements.
 |      It does *not* generally hold that ``self.strides[-1] == self.itemsize``
 |      for C-style contiguous arrays or ``self.strides[0] == self.itemsize`` for
 |      Fortran-style contiguous arrays is true.
 |  
 |  flat
 |      A 1-D iterator over the array.
 |      
 |      This is a `numpy.flatiter` instance, which acts similarly to, but is not
 |      a subclass of, Python's built-in iterator object.
 |      
 |      See Also
 |      --------
 |      flatten : Return a copy of the array collapsed into one dimension.
 |      
 |      flatiter
 |      
 |      Examples
 |      --------
 |      >>> x = np.arange(1, 7).reshape(2, 3)
 |      >>> x
 |      array([[1, 2, 3],
 |             [4, 5, 6]])
 |      >>> x.flat[3]
 |      4
 |      >>> x.T
 |      array([[1, 4],
 |             [2, 5],
 |             [3, 6]])
 |      >>> x.T.flat[3]
 |      5
 |      >>> type(x.flat)
 |      <type 'numpy.flatiter'>
 |      
 |      An assignment example:
 |      
 |      >>> x.flat = 3; x
 |      array([[3, 3, 3],
 |             [3, 3, 3]])
 |      >>> x.flat[[1,4]] = 1; x
 |      array([[3, 1, 3],
 |             [3, 1, 3]])
 |  
 |  imag
 |      The imaginary part of the array.
 |      
 |      Examples
 |      --------
 |      >>> x = np.sqrt([1+0j, 0+1j])
 |      >>> x.imag
 |      array([ 0.        ,  0.70710678])
 |      >>> x.imag.dtype
 |      dtype('float64')
 |  
 |  itemsize
 |      Length of one array element in bytes.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1,2,3], dtype=np.float64)
 |      >>> x.itemsize
 |      8
 |      >>> x = np.array([1,2,3], dtype=np.complex128)
 |      >>> x.itemsize
 |      16
 |  
 |  nbytes
 |      Total bytes consumed by the elements of the array.
 |      
 |      Notes
 |      -----
 |      Does not include memory consumed by non-element attributes of the
 |      array object.
 |      
 |      Examples
 |      --------
 |      >>> x = np.zeros((3,5,2), dtype=np.complex128)
 |      >>> x.nbytes
 |      480
 |      >>> np.prod(x.shape) * x.itemsize
 |      480
 |  
 |  ndim
 |      Number of array dimensions.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 3])
 |      >>> x.ndim
 |      1
 |      >>> y = np.zeros((2, 3, 4))
 |      >>> y.ndim
 |      3
 |  
 |  real
 |      The real part of the array.
 |      
 |      Examples
 |      --------
 |      >>> x = np.sqrt([1+0j, 0+1j])
 |      >>> x.real
 |      array([ 1.        ,  0.70710678])
 |      >>> x.real.dtype
 |      dtype('float64')
 |      
 |      See Also
 |      --------
 |      numpy.real : equivalent function
 |  
 |  shape
 |      Tuple of array dimensions.
 |      
 |      The shape property is usually used to get the current shape of an array,
 |      but may also be used to reshape the array in-place by assigning a tuple of
 |      array dimensions to it.  As with `numpy.reshape`, one of the new shape
 |      dimensions can be -1, in which case its value is inferred from the size of
 |      the array and the remaining dimensions. Reshaping an array in-place will
 |      fail if a copy is required.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 3, 4])
 |      >>> x.shape
 |      (4,)
 |      >>> y = np.zeros((2, 3, 4))
 |      >>> y.shape
 |      (2, 3, 4)
 |      >>> y.shape = (3, 8)
 |      >>> y
 |      array([[ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
 |             [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
 |             [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.]])
 |      >>> y.shape = (3, 6)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: total size of new array must be unchanged
 |      >>> np.zeros((4,2))[::2].shape = (-1,)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      AttributeError: incompatible shape for a non-contiguous array
 |      
 |      See Also
 |      --------
 |      numpy.reshape : similar function
 |      ndarray.reshape : similar method
 |  
 |  size
 |      Number of elements in the array.
 |      
 |      Equivalent to ``np.prod(a.shape)``, i.e., the product of the array's
 |      dimensions.
 |      
 |      Examples
 |      --------
 |      >>> x = np.zeros((3, 5, 2), dtype=np.complex128)
 |      >>> x.size
 |      30
 |      >>> np.prod(x.shape)
 |      30
 |  
 |  strides
 |      Tuple of bytes to step in each dimension when traversing an array.
 |      
 |      The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a`
 |      is::
 |      
 |          offset = sum(np.array(i) * a.strides)
 |      
 |      A more detailed explanation of strides can be found in the
 |      ""ndarray.rst"" file in the NumPy reference guide.
 |      
 |      Notes
 |      -----
 |      Imagine an array of 32-bit integers (each 4 bytes)::
 |      
 |        x = np.array([[0, 1, 2, 3, 4],
 |                      [5, 6, 7, 8, 9]], dtype=np.int32)
 |      
 |      This array is stored in memory as 40 bytes, one after the other
 |      (known as a contiguous block of memory).  The strides of an array tell
 |      us how many bytes we have to skip in memory to move to the next position
 |      along a certain axis.  For example, we have to skip 4 bytes (1 value) to
 |      move to the next column, but 20 bytes (5 values) to get to the same
 |      position in the next row.  As such, the strides for the array `x` will be
 |      ``(20, 4)``.
 |      
 |      See Also
 |      --------
 |      numpy.lib.stride_tricks.as_strided
 |      
 |      Examples
 |      --------
 |      >>> y = np.reshape(np.arange(2*3*4), (2,3,4))
 |      >>> y
 |      array([[[ 0,  1,  2,  3],
 |              [ 4,  5,  6,  7],
 |              [ 8,  9, 10, 11]],
 |             [[12, 13, 14, 15],
 |              [16, 17, 18, 19],
 |              [20, 21, 22, 23]]])
 |      >>> y.strides
 |      (48, 16, 4)
 |      >>> y[1,1,1]
 |      17
 |      >>> offset=sum(y.strides * np.array((1,1,1)))
 |      >>> offset/y.itemsize
 |      17
 |      
 |      >>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0)
 |      >>> x.strides
 |      (32, 4, 224, 1344)
 |      >>> i = np.array([3,5,2,2])
 |      >>> offset = sum(i * x.strides)
 |      >>> x[3,5,2,2]
 |      813
 |      >>> offset / x.itemsize
 |      813
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from numpy.ndarray:
 |  
 |  __hash__ = None
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.matlab.mio5_params._convert_codecs,io.matlab.mio5_params,_convert_codecs,"Python Library Documentation: function _convert_codecs in module scipy.io.matlab.mio5_params

_convert_codecs(template, byte_order)
    Convert codec template mapping to byte order
    
    Set codecs not on this system to None
    
    Parameters
    ----------
    template : mapping
       key, value are respectively codec name, and root name for codec
       (without byte order suffix)
    byte_order : {'<', '>'}
       code for little or big endian
    
    Returns
    -------
    codecs : dict
       key, value are name, codec (as in .encode(codec))
",function,"('(template, byte_order)',)",scipy,1.1.0,scipy.io.matlab.mio5_params._convert_codecs,io.matlab.mio5_params,_convert_codecs,"Python Library Documentation: function _convert_codecs in module scipy.io.matlab.mio5_params

_convert_codecs(template, byte_order)
    Convert codec template mapping to byte order
    
    Set codecs not on this system to None
    
    Parameters
    ----------
    template : mapping
       key, value are respectively codec name, and root name for codec
       (without byte order suffix)
    byte_order : {'<', '>'}
       code for little or big endian
    
    Returns
    -------
    codecs : dict
       key, value are name, codec (as in .encode(codec))
",function,"('template', 'byte_order')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(template, byte_order)',)"
scipy,1.1.0,scipy.io.matlab.mio5_params.convert_dtypes,io.matlab.mio5_params,convert_dtypes,"Python Library Documentation: function convert_dtypes in module scipy.io.matlab.miobase

convert_dtypes(dtype_template, order_code)
    Convert dtypes in mapping to given order
    
    Parameters
    ----------
    dtype_template : mapping
       mapping with values returning numpy dtype from ``np.dtype(val)``
    order_code : str
       an order code suitable for using in ``dtype.newbyteorder()``
    
    Returns
    -------
    dtypes : mapping
       mapping where values have been replaced by
       ``np.dtype(val).newbyteorder(order_code)``
",function,"('(dtype_template, order_code)',)",scipy,1.1.0,scipy.io.matlab.mio5_params.convert_dtypes,io.matlab.mio5_params,convert_dtypes,"Python Library Documentation: function convert_dtypes in module scipy.io.matlab.miobase

convert_dtypes(dtype_template, order_code)
    Convert dtypes in mapping to given order
    
    Parameters
    ----------
    dtype_template : mapping
       mapping with values returning numpy dtype from ``np.dtype(val)``
    order_code : str
       an order code suitable for using in ``dtype.newbyteorder()``
    
    Returns
    -------
    dtypes : mapping
       mapping where values have been replaced by
       ``np.dtype(val).newbyteorder(order_code)``
",function,"('dtype_template', 'order_code')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(dtype_template, order_code)',)"
scipy,1.1.0,scipy.io.matlab.mio5_params.mat_struct,io.matlab.mio5_params,mat_struct,"Python Library Documentation: class mat_struct in module scipy.io.matlab.mio5_params

class mat_struct(builtins.object)
 |  Placeholder for holding read data from structs
 |  
 |  We use instances of this class when the user passes False as a value to the
 |  ``struct_as_record`` parameter of the :func:`scipy.io.matlab.loadmat`
 |  function.
 |  
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.matlab.mio5_params.mat_struct,io.matlab.mio5_params,mat_struct,"Python Library Documentation: class mat_struct in module scipy.io.matlab.mio5_params

class mat_struct(builtins.object)
 |  Placeholder for holding read data from structs
 |  
 |  We use instances of this class when the user passes False as a value to the
 |  ``struct_as_record`` parameter of the :func:`scipy.io.matlab.loadmat`
 |  function.
 |  
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.matlab.mio5_utils.VarHeader5,io.matlab.mio5_utils,VarHeader5,"Python Library Documentation: class VarHeader5 in module scipy.io.matlab.mio5_utils

class VarHeader5(builtins.object)
 |  Methods defined here:
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__ = __reduce_cython__(...)
 |  
 |  __setstate__ = __setstate_cython__(...)
 |  
 |  set_dims(...)
 |      Allow setting of dimensions from python
 |      
 |      This is for constructing headers for tests
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  dims
 |  
 |  is_global
 |  
 |  is_logical
 |  
 |  mclass
 |  
 |  name
 |  
 |  nzmax
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.matlab.mio5_utils.VarHeader5,io.matlab.mio5_utils,VarHeader5,"Python Library Documentation: class VarHeader5 in module scipy.io.matlab.mio5_utils

class VarHeader5(builtins.object)
 |  Methods defined here:
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__ = __reduce_cython__(...)
 |  
 |  __setstate__ = __setstate_cython__(...)
 |  
 |  set_dims(...)
 |      Allow setting of dimensions from python
 |      
 |      This is for constructing headers for tests
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  dims
 |  
 |  is_global
 |  
 |  is_logical
 |  
 |  mclass
 |  
 |  name
 |  
 |  nzmax
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.matlab.mio5_utils.VarReader5,io.matlab.mio5_utils,VarReader5,"Python Library Documentation: class VarReader5 in module scipy.io.matlab.mio5_utils

class VarReader5(builtins.object)
 |  Methods defined here:
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__ = __reduce_cython__(...)
 |  
 |  __setstate__ = __setstate_cython__(...)
 |  
 |  array_from_header(...)
 |      Read array of any class, given matrix `header`
 |      
 |      Parameters
 |      ----------
 |      header : VarHeader5
 |         array header object
 |      process : int, optional
 |         If not zero, apply post-processing on returned array
 |         
 |      Returns
 |      -------
 |      arr : array or sparse array
 |         read array
 |  
 |  read_cells(...)
 |      Read cell array from stream
 |  
 |  read_char(...)
 |      Read char matrices from stream as arrays
 |      
 |      Matrices of char are likely to be converted to matrices of
 |      string by later processing in ``array_from_header``
 |  
 |  read_fieldnames(...)
 |      Read fieldnames for struct-like matrix.
 |  
 |  read_full_tag(...)
 |      Python method for reading full u4, u4 tag from stream
 |      
 |      Returns
 |      -------
 |      mdtype : int32
 |         matlab data type code
 |      byte_count : int32
 |         number of data bytes following
 |      
 |      Notes
 |      -----
 |      Assumes tag is in fact full, that is, is not a small data
 |      element.  This means it can skip some checks and makes it
 |      slightly faster than ``read_tag``
 |  
 |  read_header(...)
 |      Return matrix header for current stream position
 |      
 |      Returns matrix headers at top level and sub levels
 |      
 |      Parameters
 |      ----------
 |      check_stream_limit : if True, then if the returned header
 |      is passed to array_from_header, it will be verified that
 |      the length of the uncompressed data is not overlong (which
 |      can indicate .mat file corruption)
 |  
 |  read_numeric(...)
 |      Read numeric data element into ndarray
 |      
 |      Reads element, then casts to ndarray.
 |      
 |      The type of the array is usually given by the ``mdtype`` returned via
 |      ``read_element``.  Sparse logical arrays are an exception, where the
 |      type of the array may be ``np.bool`` even if the ``mdtype`` claims the
 |      data is of float64 type.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          Whether to copy the array before returning.  If False, return array
 |          backed by bytes read from file.
 |      nnz : int, optional
 |          Number of non-zero values when reading numeric data from sparse
 |          matrices.  -1 if not reading sparse matrices, or to disable check
 |          for bytes data instead of declared data type (see Notes).
 |      
 |      Returns
 |      -------
 |      arr : array
 |          Numeric array
 |      
 |      Notes
 |      -----
 |      MATLAB apparently likes to store sparse logical matrix data as bytes
 |      instead of miDOUBLE (float64) data type, even though the data element
 |      still declares its type as miDOUBLE.  We can guess this has happened by
 |      looking for the length of the data compared to the expected number of
 |      elements, using the `nnz` input parameter.
 |  
 |  read_opaque(...)
 |      Read opaque (function workspace) type
 |      
 |      Looking at some mat files, the structure of this type seems to
 |      be:
 |      
 |      * array flags as usual (already read into `hdr`)
 |      * 3 int8 strings
 |      * a matrix
 |      
 |      Then there's a matrix at the end of the mat file that seems have
 |      the anonymous founction workspaces - we load it as
 |      ``__function_workspace__``
 |      
 |      See the comments at the beginning of ``mio5.py``
 |  
 |  read_real_complex(...)
 |      Read real / complex matrices from stream
 |  
 |  read_struct(...)
 |      Read struct or object array from stream
 |      
 |      Objects are just structs with an extra field *classname*,
 |      defined before (this here) struct format structure
 |  
 |  read_tag(...)
 |      Read tag mdtype and byte_count
 |      
 |      Does necessary swapping and takes account of SDE formats.
 |      
 |      See also ``read_full_tag`` method.
 |      
 |      Returns
 |      -------
 |      mdtype : int
 |         matlab data type code
 |      byte_count : int
 |         number of bytes following that comprise the data
 |      tag_data : None or str
 |         Any data from the tag itself.  This is None for a full tag,
 |         and string length `byte_count` if this is a small data
 |         element.
 |  
 |  set_stream(...)
 |      Set stream of best type from file-like `fobj`
 |      
 |      Called from Python when initiating a variable read
 |  
 |  shape_from_header(...)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  is_swapped
 |  
 |  little_endian
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __pyx_vtable__ = <capsule object NULL>
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.matlab.mio5_utils.VarReader5,io.matlab.mio5_utils,VarReader5,"Python Library Documentation: class VarReader5 in module scipy.io.matlab.mio5_utils

class VarReader5(builtins.object)
 |  Methods defined here:
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__ = __reduce_cython__(...)
 |  
 |  __setstate__ = __setstate_cython__(...)
 |  
 |  array_from_header(...)
 |      Read array of any class, given matrix `header`
 |      
 |      Parameters
 |      ----------
 |      header : VarHeader5
 |         array header object
 |      process : int, optional
 |         If not zero, apply post-processing on returned array
 |         
 |      Returns
 |      -------
 |      arr : array or sparse array
 |         read array
 |  
 |  read_cells(...)
 |      Read cell array from stream
 |  
 |  read_char(...)
 |      Read char matrices from stream as arrays
 |      
 |      Matrices of char are likely to be converted to matrices of
 |      string by later processing in ``array_from_header``
 |  
 |  read_fieldnames(...)
 |      Read fieldnames for struct-like matrix.
 |  
 |  read_full_tag(...)
 |      Python method for reading full u4, u4 tag from stream
 |      
 |      Returns
 |      -------
 |      mdtype : int32
 |         matlab data type code
 |      byte_count : int32
 |         number of data bytes following
 |      
 |      Notes
 |      -----
 |      Assumes tag is in fact full, that is, is not a small data
 |      element.  This means it can skip some checks and makes it
 |      slightly faster than ``read_tag``
 |  
 |  read_header(...)
 |      Return matrix header for current stream position
 |      
 |      Returns matrix headers at top level and sub levels
 |      
 |      Parameters
 |      ----------
 |      check_stream_limit : if True, then if the returned header
 |      is passed to array_from_header, it will be verified that
 |      the length of the uncompressed data is not overlong (which
 |      can indicate .mat file corruption)
 |  
 |  read_numeric(...)
 |      Read numeric data element into ndarray
 |      
 |      Reads element, then casts to ndarray.
 |      
 |      The type of the array is usually given by the ``mdtype`` returned via
 |      ``read_element``.  Sparse logical arrays are an exception, where the
 |      type of the array may be ``np.bool`` even if the ``mdtype`` claims the
 |      data is of float64 type.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          Whether to copy the array before returning.  If False, return array
 |          backed by bytes read from file.
 |      nnz : int, optional
 |          Number of non-zero values when reading numeric data from sparse
 |          matrices.  -1 if not reading sparse matrices, or to disable check
 |          for bytes data instead of declared data type (see Notes).
 |      
 |      Returns
 |      -------
 |      arr : array
 |          Numeric array
 |      
 |      Notes
 |      -----
 |      MATLAB apparently likes to store sparse logical matrix data as bytes
 |      instead of miDOUBLE (float64) data type, even though the data element
 |      still declares its type as miDOUBLE.  We can guess this has happened by
 |      looking for the length of the data compared to the expected number of
 |      elements, using the `nnz` input parameter.
 |  
 |  read_opaque(...)
 |      Read opaque (function workspace) type
 |      
 |      Looking at some mat files, the structure of this type seems to
 |      be:
 |      
 |      * array flags as usual (already read into `hdr`)
 |      * 3 int8 strings
 |      * a matrix
 |      
 |      Then there's a matrix at the end of the mat file that seems have
 |      the anonymous founction workspaces - we load it as
 |      ``__function_workspace__``
 |      
 |      See the comments at the beginning of ``mio5.py``
 |  
 |  read_real_complex(...)
 |      Read real / complex matrices from stream
 |  
 |  read_struct(...)
 |      Read struct or object array from stream
 |      
 |      Objects are just structs with an extra field *classname*,
 |      defined before (this here) struct format structure
 |  
 |  read_tag(...)
 |      Read tag mdtype and byte_count
 |      
 |      Does necessary swapping and takes account of SDE formats.
 |      
 |      See also ``read_full_tag`` method.
 |      
 |      Returns
 |      -------
 |      mdtype : int
 |         matlab data type code
 |      byte_count : int
 |         number of bytes following that comprise the data
 |      tag_data : None or str
 |         Any data from the tag itself.  This is None for a full tag,
 |         and string length `byte_count` if this is a small data
 |         element.
 |  
 |  set_stream(...)
 |      Set stream of best type from file-like `fobj`
 |      
 |      Called from Python when initiating a variable read
 |  
 |  shape_from_header(...)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  is_swapped
 |  
 |  little_endian
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __pyx_vtable__ = <capsule object NULL>
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.matlab.mio5_utils.asbytes,io.matlab.mio5_utils,asbytes,"Python Library Documentation: function asbytes in module numpy.compat.py3k

asbytes(s)
",function,"('(s)',)",scipy,1.1.0,scipy.io.matlab.mio5_utils.asbytes,io.matlab.mio5_utils,asbytes,"Python Library Documentation: function asbytes in module numpy.compat.py3k

asbytes(s)
",function,"('s',)","(nan,)","(nan,)","('arg_info',)","('(s)',)"
scipy,1.1.0,scipy.io.matlab.mio5_utils.asstr,io.matlab.mio5_utils,asstr,"Python Library Documentation: function asstr in module numpy.compat.py3k

asstr(s)
",function,"('(s)',)",scipy,1.1.0,scipy.io.matlab.mio5_utils.asstr,io.matlab.mio5_utils,asstr,"Python Library Documentation: function asstr in module numpy.compat.py3k

asstr(s)
",function,"('s',)","(nan,)","(nan,)","('arg_info',)","('(s)',)"
scipy,1.1.0,scipy.io.matlab.mio5_utils.csc_matrix,io.matlab.mio5_utils,csc_matrix,"Python Library Documentation: class csc_matrix in module scipy.sparse.csc

class csc_matrix(scipy.sparse.compressed._cs_matrix, scipy.sparse.sputils.IndexMixin)
 |  Compressed Sparse Column matrix
 |  
 |  This can be instantiated in several ways:
 |  
 |      csc_matrix(D)
 |          with a dense matrix or rank-2 ndarray D
 |  
 |      csc_matrix(S)
 |          with another sparse matrix S (equivalent to S.tocsc())
 |  
 |      csc_matrix((M, N), [dtype])
 |          to construct an empty matrix with shape (M, N)
 |          dtype is optional, defaulting to dtype='d'.
 |  
 |      csc_matrix((data, (row_ind, col_ind)), [shape=(M, N)])
 |          where ``data``, ``row_ind`` and ``col_ind`` satisfy the
 |          relationship ``a[row_ind[k], col_ind[k]] = data[k]``.
 |  
 |      csc_matrix((data, indices, indptr), [shape=(M, N)])
 |          is the standard CSC representation where the row indices for
 |          column i are stored in ``indices[indptr[i]:indptr[i+1]]``
 |          and their corresponding values are stored in
 |          ``data[indptr[i]:indptr[i+1]]``.  If the shape parameter is
 |          not supplied, the matrix dimensions are inferred from
 |          the index arrays.
 |  
 |  Attributes
 |  ----------
 |  dtype : dtype
 |      Data type of the matrix
 |  shape : 2-tuple
 |      Shape of the matrix
 |  ndim : int
 |      Number of dimensions (this is always 2)
 |  nnz
 |      Number of nonzero elements
 |  data
 |      Data array of the matrix
 |  indices
 |      CSC format index array
 |  indptr
 |      CSC format index pointer array
 |  has_sorted_indices
 |      Whether indices are sorted
 |  
 |  Notes
 |  -----
 |  
 |  Sparse matrices can be used in arithmetic operations: they support
 |  addition, subtraction, multiplication, division, and matrix power.
 |  
 |  Advantages of the CSC format
 |      - efficient arithmetic operations CSC + CSC, CSC * CSC, etc.
 |      - efficient column slicing
 |      - fast matrix vector products (CSR, BSR may be faster)
 |  
 |  Disadvantages of the CSC format
 |    - slow row slicing operations (consider CSR)
 |    - changes to the sparsity structure are expensive (consider LIL or DOK)
 |  
 |  
 |  Examples
 |  --------
 |  
 |  >>> import numpy as np
 |  >>> from scipy.sparse import csc_matrix
 |  >>> csc_matrix((3, 4), dtype=np.int8).toarray()
 |  array([[0, 0, 0, 0],
 |         [0, 0, 0, 0],
 |         [0, 0, 0, 0]], dtype=int8)
 |  
 |  >>> row = np.array([0, 2, 2, 0, 1, 2])
 |  >>> col = np.array([0, 0, 1, 2, 2, 2])
 |  >>> data = np.array([1, 2, 3, 4, 5, 6])
 |  >>> csc_matrix((data, (row, col)), shape=(3, 3)).toarray()
 |  array([[1, 0, 4],
 |         [0, 0, 5],
 |         [2, 3, 6]])
 |  
 |  >>> indptr = np.array([0, 2, 3, 6])
 |  >>> indices = np.array([0, 2, 2, 0, 1, 2])
 |  >>> data = np.array([1, 2, 3, 4, 5, 6])
 |  >>> csc_matrix((data, indices, indptr), shape=(3, 3)).toarray()
 |  array([[1, 0, 4],
 |         [0, 0, 5],
 |         [2, 3, 6]])
 |  
 |  Method resolution order:
 |      csc_matrix
 |      scipy.sparse.compressed._cs_matrix
 |      scipy.sparse.data._data_matrix
 |      scipy.sparse.base.spmatrix
 |      scipy.sparse.data._minmax_mixin
 |      scipy.sparse.sputils.IndexMixin
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __getitem__(self, key)
 |  
 |  __iter__(self)
 |  
 |  getcol(self, i)
 |      Returns a copy of column i of the matrix, as a (m x 1)
 |      CSC matrix (column vector).
 |  
 |  getrow(self, i)
 |      Returns a copy of row i of the matrix, as a (1 x n)
 |      CSR matrix (row vector).
 |  
 |  nonzero(self)
 |      nonzero indices
 |      
 |      Returns a tuple of arrays (row,col) containing the indices
 |      of the non-zero elements of the matrix.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1,2,0],[0,0,3],[4,0,5]])
 |      >>> A.nonzero()
 |      (array([0, 0, 1, 2, 2]), array([0, 1, 2, 0, 2]))
 |  
 |  tocsc(self, copy=False)
 |      Convert this matrix to Compressed Sparse Column format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant csc_matrix.
 |  
 |  tocsr(self, copy=False)
 |      Convert this matrix to Compressed Sparse Row format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant csr_matrix.
 |  
 |  transpose(self, axes=None, copy=False)
 |      Reverses the dimensions of the sparse matrix.
 |      
 |      Parameters
 |      ----------
 |      axes : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value.
 |      copy : bool, optional
 |          Indicates whether or not attributes of `self` should be
 |          copied whenever possible. The degree to which attributes
 |          are copied varies depending on the type of sparse matrix
 |          being used.
 |      
 |      Returns
 |      -------
 |      p : `self` with the dimensions reversed.
 |      
 |      See Also
 |      --------
 |      np.matrix.transpose : NumPy's implementation of 'transpose'
 |                            for matrices
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  format = 'csc'
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.compressed._cs_matrix:
 |  
 |  __eq__(self, other)
 |      Return self==value.
 |  
 |  __ge__(self, other)
 |      Return self>=value.
 |  
 |  __gt__(self, other)
 |      Return self>value.
 |  
 |  __init__(self, arg1, shape=None, dtype=None, copy=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __le__(self, other)
 |      Return self<=value.
 |  
 |  __lt__(self, other)
 |      Return self<value.
 |  
 |  __ne__(self, other)
 |      Return self!=value.
 |  
 |  __setitem__(self, index, x)
 |  
 |  check_format(self, full_check=True)
 |      check whether the matrix format is valid
 |      
 |      Parameters
 |      ----------
 |      full_check : bool, optional
 |          If `True`, rigorous check, O(N) operations. Otherwise
 |          basic check, O(1) operations (default True).
 |  
 |  diagonal(self, k=0)
 |      Returns the k-th diagonal of the matrix.
 |      
 |      Parameters
 |      ----------
 |      k : int, optional
 |          Which diagonal to set, corresponding to elements a[i, i+k].
 |          Default: 0 (the main diagonal).
 |      
 |          .. versionadded:: 1.0
 |      
 |      See also
 |      --------
 |      numpy.diagonal : Equivalent numpy function.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> A.diagonal()
 |      array([1, 0, 5])
 |      >>> A.diagonal(k=1)
 |      array([2, 3])
 |  
 |  eliminate_zeros(self)
 |      Remove zero entries from the matrix
 |      
 |      This is an *in place* operation
 |  
 |  getnnz(self, axis=None)
 |      Number of stored values, including explicit zeros.
 |      
 |      Parameters
 |      ----------
 |      axis : None, 0, or 1
 |          Select between the number of values across the whole matrix, in
 |          each column, or in each row.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  maximum(self, other)
 |      Element-wise maximum between this and another matrix.
 |  
 |  minimum(self, other)
 |      Element-wise minimum between this and another matrix.
 |  
 |  multiply(self, other)
 |      Point-wise multiplication by another matrix, vector, or
 |      scalar.
 |  
 |  prune(self)
 |      Remove empty space after all non-zero elements.
 |  
 |  resize(self, *shape)
 |      Resize the matrix in-place to dimensions given by ``shape``
 |      
 |      Any elements that lie within the new shape will remain at the same
 |      indices, while non-zero elements lying outside the new shape are
 |      removed.
 |      
 |      Parameters
 |      ----------
 |      shape : (int, int)
 |          number of rows and columns in the new matrix
 |      
 |      Notes
 |      -----
 |      The semantics are not identical to `numpy.ndarray.resize` or
 |      `numpy.resize`.  Here, the same data will be maintained at each index
 |      before and after reshape, if that index is within the new bounds.  In
 |      numpy, resizing maintains contiguity of the array, moving elements
 |      around in the logical matrix but not within a flattened representation.
 |      
 |      We give no guarantees about whether the underlying data attributes
 |      (arrays, etc.) will be modified in place or replaced with new objects.
 |  
 |  sort_indices(self)
 |      Sort the indices of this matrix *in place*
 |  
 |  sorted_indices(self)
 |      Return a copy of this matrix with sorted indices
 |  
 |  sum(self, axis=None, dtype=None, out=None)
 |      Sum the matrix elements over a given axis.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the sum of all the matrix elements, returning a scalar
 |          (i.e. `axis` = `None`).
 |      dtype : dtype, optional
 |          The type of the returned matrix and of the accumulator in which
 |          the elements are summed.  The dtype of `a` is used by default
 |          unless `a` has an integer dtype of less precision than the default
 |          platform integer.  In that case, if `a` is signed then the platform
 |          integer is used while if `a` is unsigned then an unsigned integer
 |          of the same precision as the platform integer is used.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      sum_along_axis : np.matrix
 |          A matrix with the same shape as `self`, with the specified
 |          axis removed.
 |      
 |      See Also
 |      --------
 |      np.matrix.sum : NumPy's implementation of 'sum' for matrices
 |  
 |  sum_duplicates(self)
 |      Eliminate duplicate matrix entries by adding them together
 |      
 |      The is an *in place* operation
 |  
 |  toarray(self, order=None, out=None)
 |      Return a dense ndarray representation of this matrix.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F'}, optional
 |          Whether to store multi-dimensional data in C (row-major)
 |          or Fortran (column-major) order in memory. The default
 |          is 'None', indicating the NumPy default of C-ordered.
 |          Cannot be specified in conjunction with the `out`
 |          argument.
 |      
 |      out : ndarray, 2-dimensional, optional
 |          If specified, uses this array as the output buffer
 |          instead of allocating a new array to return. The provided
 |          array must have the same shape and dtype as the sparse
 |          matrix on which you are calling the method. For most
 |          sparse types, `out` is required to be memory contiguous
 |          (either C or Fortran ordered).
 |      
 |      Returns
 |      -------
 |      arr : ndarray, 2-dimensional
 |          An array with the same shape and containing the same
 |          data represented by the sparse matrix, with the requested
 |          memory order. If `out` was passed, the same object is
 |          returned after being modified in-place to contain the
 |          appropriate values.
 |  
 |  tocoo(self, copy=True)
 |      Convert this matrix to COOrdinate format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant coo_matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.compressed._cs_matrix:
 |  
 |  has_canonical_format
 |      Determine whether the matrix has sorted indices and no duplicates
 |      
 |      Returns
 |          - True: if the above applies
 |          - False: otherwise
 |      
 |      has_canonical_format implies has_sorted_indices, so if the latter flag
 |      is False, so will the former be; if the former is found True, the
 |      latter flag is also set.
 |  
 |  has_sorted_indices
 |      Determine whether the matrix has sorted indices
 |      
 |      Returns
 |          - True: if the indices of the matrix are in sorted order
 |          - False: otherwise
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.sparse.compressed._cs_matrix:
 |  
 |  __hash__ = None
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._data_matrix:
 |  
 |  __abs__(self)
 |  
 |  __imul__(self, other)
 |  
 |  __itruediv__(self, other)
 |  
 |  __neg__(self)
 |  
 |  arcsin(self)
 |      Element-wise arcsin.
 |      
 |      See numpy.arcsin for more information.
 |  
 |  arcsinh(self)
 |      Element-wise arcsinh.
 |      
 |      See numpy.arcsinh for more information.
 |  
 |  arctan(self)
 |      Element-wise arctan.
 |      
 |      See numpy.arctan for more information.
 |  
 |  arctanh(self)
 |      Element-wise arctanh.
 |      
 |      See numpy.arctanh for more information.
 |  
 |  astype(self, dtype, casting='unsafe', copy=True)
 |      Cast the matrix elements to a specified type.
 |      
 |      Parameters
 |      ----------
 |      dtype : string or numpy dtype
 |          Typecode or data-type to which to cast the data.
 |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
 |          Controls what kind of data casting may occur.
 |          Defaults to 'unsafe' for backwards compatibility.
 |          'no' means the data types should not be cast at all.
 |          'equiv' means only byte-order changes are allowed.
 |          'safe' means only casts which can preserve values are allowed.
 |          'same_kind' means only safe casts or casts within a kind,
 |          like float64 to float32, are allowed.
 |          'unsafe' means any data conversions may be done.
 |      copy : bool, optional
 |          If `copy` is `False`, the result might share some memory with this
 |          matrix. If `copy` is `True`, it is guaranteed that the result and
 |          this matrix do not share any memory.
 |  
 |  ceil(self)
 |      Element-wise ceil.
 |      
 |      See numpy.ceil for more information.
 |  
 |  conj(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  copy(self)
 |      Returns a copy of this matrix.
 |      
 |      No data/indices will be shared between the returned value and current
 |      matrix.
 |  
 |  count_nonzero(self)
 |      Number of non-zero entries, equivalent to
 |      
 |      np.count_nonzero(a.toarray())
 |      
 |      Unlike getnnz() and the nnz property, which return the number of stored
 |      entries (the length of the data attribute), this method counts the
 |      actual number of non-zero entries in data.
 |  
 |  deg2rad(self)
 |      Element-wise deg2rad.
 |      
 |      See numpy.deg2rad for more information.
 |  
 |  expm1(self)
 |      Element-wise expm1.
 |      
 |      See numpy.expm1 for more information.
 |  
 |  floor(self)
 |      Element-wise floor.
 |      
 |      See numpy.floor for more information.
 |  
 |  log1p(self)
 |      Element-wise log1p.
 |      
 |      See numpy.log1p for more information.
 |  
 |  power(self, n, dtype=None)
 |      This function performs element-wise power.
 |      
 |      Parameters
 |      ----------
 |      n : n is a scalar
 |      
 |      dtype : If dtype is not specified, the current dtype will be preserved.
 |  
 |  rad2deg(self)
 |      Element-wise rad2deg.
 |      
 |      See numpy.rad2deg for more information.
 |  
 |  rint(self)
 |      Element-wise rint.
 |      
 |      See numpy.rint for more information.
 |  
 |  sign(self)
 |      Element-wise sign.
 |      
 |      See numpy.sign for more information.
 |  
 |  sin(self)
 |      Element-wise sin.
 |      
 |      See numpy.sin for more information.
 |  
 |  sinh(self)
 |      Element-wise sinh.
 |      
 |      See numpy.sinh for more information.
 |  
 |  sqrt(self)
 |      Element-wise sqrt.
 |      
 |      See numpy.sqrt for more information.
 |  
 |  tan(self)
 |      Element-wise tan.
 |      
 |      See numpy.tan for more information.
 |  
 |  tanh(self)
 |      Element-wise tanh.
 |      
 |      See numpy.tanh for more information.
 |  
 |  trunc(self)
 |      Element-wise trunc.
 |      
 |      See numpy.trunc for more information.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.data._data_matrix:
 |  
 |  dtype
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.base.spmatrix:
 |  
 |  __add__(self, other)
 |  
 |  __bool__(self)
 |  
 |  __div__(self, other)
 |  
 |  __getattr__(self, attr)
 |  
 |  __iadd__(self, other)
 |  
 |  __idiv__(self, other)
 |  
 |  __isub__(self, other)
 |  
 |  __len__(self)
 |      # What should len(sparse) return? For consistency with dense matrices,
 |      # perhaps it should be the number of rows?  But for some uses the number of
 |      # non-zeros is more important.  For now, raise an exception!
 |  
 |  __matmul__(self, other)
 |  
 |  __mul__(self, other)
 |      interpret other and call one of the following
 |      
 |      self._mul_scalar()
 |      self._mul_vector()
 |      self._mul_multivector()
 |      self._mul_sparse_matrix()
 |  
 |  __nonzero__ = __bool__(self)
 |  
 |  __pow__(self, other)
 |  
 |  __radd__(self, other)
 |  
 |  __rdiv__(self, other)
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __rmatmul__(self, other)
 |  
 |  __rmul__(self, other)
 |  
 |  __rsub__(self, other)
 |  
 |  __rtruediv__(self, other)
 |  
 |  __str__(self)
 |      Return str(self).
 |  
 |  __sub__(self, other)
 |  
 |  __truediv__(self, other)
 |  
 |  asformat(self, format, copy=False)
 |      Return this matrix in the passed sparse format.
 |      
 |      Parameters
 |      ----------
 |      format : {str, None}
 |          The desired sparse matrix format (""csr"", ""csc"", ""lil"", ""dok"", ...)
 |          or None for no conversion.
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : This matrix in the passed sparse format.
 |  
 |  asfptype(self)
 |      Upcast matrix to a floating point format (if necessary)
 |  
 |  conjugate(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  dot(self, other)
 |      Ordinary dot product
 |      
 |      Examples
 |      --------
 |      >>> import numpy as np
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> v = np.array([1, 0, -1])
 |      >>> A.dot(v)
 |      array([ 1, -3, -1], dtype=int64)
 |  
 |  getH(self)
 |      Return the Hermitian transpose of this matrix.
 |      
 |      See Also
 |      --------
 |      np.matrix.getH : NumPy's implementation of `getH` for matrices
 |  
 |  get_shape(self)
 |      Get shape of a matrix.
 |  
 |  getformat(self)
 |      Format of a matrix representation as a string.
 |  
 |  getmaxprint(self)
 |      Maximum number of elements to display when printed.
 |  
 |  mean(self, axis=None, dtype=None, out=None)
 |      Compute the arithmetic mean along the specified axis.
 |      
 |      Returns the average of the matrix elements. The average is taken
 |      over all elements in the matrix by default, otherwise over the
 |      specified axis. `float64` intermediate and return values are used
 |      for integer inputs.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the mean is computed. The default is to compute
 |          the mean of all elements in the matrix (i.e. `axis` = `None`).
 |      dtype : data-type, optional
 |          Type to use in computing the mean. For integer inputs, the default
 |          is `float64`; for floating point inputs, it is the same as the
 |          input dtype.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      m : np.matrix
 |      
 |      See Also
 |      --------
 |      np.matrix.mean : NumPy's implementation of 'mean' for matrices
 |  
 |  reshape(self, *args, **kwargs)
 |      reshape(self, shape, order='C', copy=False)
 |      
 |      Gives a new shape to a sparse matrix without changing its data.
 |      
 |      Parameters
 |      ----------
 |      shape : length-2 tuple of ints
 |          The new shape should be compatible with the original shape.
 |      order : {'C', 'F'}, optional
 |          Read the elements using this index order. 'C' means to read and
 |          write the elements using C-like index order; e.g. read entire first
 |          row, then second row, etc. 'F' means to read and write the elements
 |          using Fortran-like index order; e.g. read entire first column, then
 |          second column, etc.
 |      copy : bool, optional
 |          Indicates whether or not attributes of self should be copied
 |          whenever possible. The degree to which attributes are copied varies
 |          depending on the type of sparse matrix being used.
 |      
 |      Returns
 |      -------
 |      reshaped_matrix : sparse matrix
 |          A sparse matrix with the given `shape`, not necessarily of the same
 |          format as the current object.
 |      
 |      See Also
 |      --------
 |      np.matrix.reshape : NumPy's implementation of 'reshape' for matrices
 |  
 |  set_shape(self, shape)
 |      See `reshape`.
 |  
 |  setdiag(self, values, k=0)
 |      Set diagonal or off-diagonal elements of the array.
 |      
 |      Parameters
 |      ----------
 |      values : array_like
 |          New values of the diagonal elements.
 |      
 |          Values may have any length.  If the diagonal is longer than values,
 |          then the remaining diagonal entries will not be set.  If values if
 |          longer than the diagonal, then the remaining values are ignored.
 |      
 |          If a scalar value is given, all of the diagonal is set to it.
 |      
 |      k : int, optional
 |          Which off-diagonal to set, corresponding to elements a[i,i+k].
 |          Default: 0 (the main diagonal).
 |  
 |  tobsr(self, blocksize=None, copy=False)
 |      Convert this matrix to Block Sparse Row format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant bsr_matrix.
 |      
 |      When blocksize=(R, C) is provided, it will be used for construction of
 |      the bsr_matrix.
 |  
 |  todense(self, order=None, out=None)
 |      Return a dense matrix representation of this matrix.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F'}, optional
 |          Whether to store multi-dimensional data in C (row-major)
 |          or Fortran (column-major) order in memory. The default
 |          is 'None', indicating the NumPy default of C-ordered.
 |          Cannot be specified in conjunction with the `out`
 |          argument.
 |      
 |      out : ndarray, 2-dimensional, optional
 |          If specified, uses this array (or `numpy.matrix`) as the
 |          output buffer instead of allocating a new array to
 |          return. The provided array must have the same shape and
 |          dtype as the sparse matrix on which you are calling the
 |          method.
 |      
 |      Returns
 |      -------
 |      arr : numpy.matrix, 2-dimensional
 |          A NumPy matrix object with the same shape and containing
 |          the same data represented by the sparse matrix, with the
 |          requested memory order. If `out` was passed and was an
 |          array (rather than a `numpy.matrix`), it will be filled
 |          with the appropriate values and returned wrapped in a
 |          `numpy.matrix` object that shares the same memory.
 |  
 |  todia(self, copy=False)
 |      Convert this matrix to sparse DIAgonal format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dia_matrix.
 |  
 |  todok(self, copy=False)
 |      Convert this matrix to Dictionary Of Keys format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dok_matrix.
 |  
 |  tolil(self, copy=False)
 |      Convert this matrix to LInked List format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant lil_matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.base.spmatrix:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  nnz
 |      Number of stored values, including explicit zeros.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  shape
 |      Get shape of a matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.sparse.base.spmatrix:
 |  
 |  __array_priority__ = 10.1
 |  
 |  ndim = 2
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._minmax_mixin:
 |  
 |  argmax(self, axis=None, out=None)
 |      Return indices of maximum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several maximum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmax is computed. If None (default), index
 |          of the maximum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      ind : np.matrix or int
 |          Indices of maximum elements. If matrix, its size along `axis` is 1.
 |  
 |  argmin(self, axis=None, out=None)
 |      Return indices of minimum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several minimum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmin is computed. If None (default), index
 |          of the minimum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |       ind : np.matrix or int
 |          Indices of minimum elements. If matrix, its size along `axis` is 1.
 |  
 |  max(self, axis=None, out=None)
 |      Return the maximum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the maximum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amax : coo_matrix or scalar
 |          Maximum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      min : The minimum value of a sparse matrix along a given axis.
 |      np.matrix.max : NumPy's implementation of 'max' for matrices
 |  
 |  min(self, axis=None, out=None)
 |      Return the minimum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the minimum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amin : coo_matrix or scalar
 |          Minimum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      max : The maximum value of a sparse matrix along a given axis.
 |      np.matrix.min : NumPy's implementation of 'min' for matrices
",class,"('(self, arg1, shape=None, dtype=None, copy=False)',)",scipy,1.1.0,scipy.io.matlab.mio5_utils.csc_matrix,io.matlab.mio5_utils,csc_matrix,"Python Library Documentation: class csc_matrix in module scipy.sparse.csc

class csc_matrix(scipy.sparse.compressed._cs_matrix, scipy.sparse.sputils.IndexMixin)
 |  Compressed Sparse Column matrix
 |  
 |  This can be instantiated in several ways:
 |  
 |      csc_matrix(D)
 |          with a dense matrix or rank-2 ndarray D
 |  
 |      csc_matrix(S)
 |          with another sparse matrix S (equivalent to S.tocsc())
 |  
 |      csc_matrix((M, N), [dtype])
 |          to construct an empty matrix with shape (M, N)
 |          dtype is optional, defaulting to dtype='d'.
 |  
 |      csc_matrix((data, (row_ind, col_ind)), [shape=(M, N)])
 |          where ``data``, ``row_ind`` and ``col_ind`` satisfy the
 |          relationship ``a[row_ind[k], col_ind[k]] = data[k]``.
 |  
 |      csc_matrix((data, indices, indptr), [shape=(M, N)])
 |          is the standard CSC representation where the row indices for
 |          column i are stored in ``indices[indptr[i]:indptr[i+1]]``
 |          and their corresponding values are stored in
 |          ``data[indptr[i]:indptr[i+1]]``.  If the shape parameter is
 |          not supplied, the matrix dimensions are inferred from
 |          the index arrays.
 |  
 |  Attributes
 |  ----------
 |  dtype : dtype
 |      Data type of the matrix
 |  shape : 2-tuple
 |      Shape of the matrix
 |  ndim : int
 |      Number of dimensions (this is always 2)
 |  nnz
 |      Number of nonzero elements
 |  data
 |      Data array of the matrix
 |  indices
 |      CSC format index array
 |  indptr
 |      CSC format index pointer array
 |  has_sorted_indices
 |      Whether indices are sorted
 |  
 |  Notes
 |  -----
 |  
 |  Sparse matrices can be used in arithmetic operations: they support
 |  addition, subtraction, multiplication, division, and matrix power.
 |  
 |  Advantages of the CSC format
 |      - efficient arithmetic operations CSC + CSC, CSC * CSC, etc.
 |      - efficient column slicing
 |      - fast matrix vector products (CSR, BSR may be faster)
 |  
 |  Disadvantages of the CSC format
 |    - slow row slicing operations (consider CSR)
 |    - changes to the sparsity structure are expensive (consider LIL or DOK)
 |  
 |  
 |  Examples
 |  --------
 |  
 |  >>> import numpy as np
 |  >>> from scipy.sparse import csc_matrix
 |  >>> csc_matrix((3, 4), dtype=np.int8).toarray()
 |  array([[0, 0, 0, 0],
 |         [0, 0, 0, 0],
 |         [0, 0, 0, 0]], dtype=int8)
 |  
 |  >>> row = np.array([0, 2, 2, 0, 1, 2])
 |  >>> col = np.array([0, 0, 1, 2, 2, 2])
 |  >>> data = np.array([1, 2, 3, 4, 5, 6])
 |  >>> csc_matrix((data, (row, col)), shape=(3, 3)).toarray()
 |  array([[1, 0, 4],
 |         [0, 0, 5],
 |         [2, 3, 6]])
 |  
 |  >>> indptr = np.array([0, 2, 3, 6])
 |  >>> indices = np.array([0, 2, 2, 0, 1, 2])
 |  >>> data = np.array([1, 2, 3, 4, 5, 6])
 |  >>> csc_matrix((data, indices, indptr), shape=(3, 3)).toarray()
 |  array([[1, 0, 4],
 |         [0, 0, 5],
 |         [2, 3, 6]])
 |  
 |  Method resolution order:
 |      csc_matrix
 |      scipy.sparse.compressed._cs_matrix
 |      scipy.sparse.data._data_matrix
 |      scipy.sparse.base.spmatrix
 |      scipy.sparse.data._minmax_mixin
 |      scipy.sparse.sputils.IndexMixin
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __getitem__(self, key)
 |  
 |  __iter__(self)
 |  
 |  getcol(self, i)
 |      Returns a copy of column i of the matrix, as a (m x 1)
 |      CSC matrix (column vector).
 |  
 |  getrow(self, i)
 |      Returns a copy of row i of the matrix, as a (1 x n)
 |      CSR matrix (row vector).
 |  
 |  nonzero(self)
 |      nonzero indices
 |      
 |      Returns a tuple of arrays (row,col) containing the indices
 |      of the non-zero elements of the matrix.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1,2,0],[0,0,3],[4,0,5]])
 |      >>> A.nonzero()
 |      (array([0, 0, 1, 2, 2]), array([0, 1, 2, 0, 2]))
 |  
 |  tocsc(self, copy=False)
 |      Convert this matrix to Compressed Sparse Column format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant csc_matrix.
 |  
 |  tocsr(self, copy=False)
 |      Convert this matrix to Compressed Sparse Row format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant csr_matrix.
 |  
 |  transpose(self, axes=None, copy=False)
 |      Reverses the dimensions of the sparse matrix.
 |      
 |      Parameters
 |      ----------
 |      axes : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value.
 |      copy : bool, optional
 |          Indicates whether or not attributes of `self` should be
 |          copied whenever possible. The degree to which attributes
 |          are copied varies depending on the type of sparse matrix
 |          being used.
 |      
 |      Returns
 |      -------
 |      p : `self` with the dimensions reversed.
 |      
 |      See Also
 |      --------
 |      np.matrix.transpose : NumPy's implementation of 'transpose'
 |                            for matrices
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  format = 'csc'
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.compressed._cs_matrix:
 |  
 |  __eq__(self, other)
 |      Return self==value.
 |  
 |  __ge__(self, other)
 |      Return self>=value.
 |  
 |  __gt__(self, other)
 |      Return self>value.
 |  
 |  __init__(self, arg1, shape=None, dtype=None, copy=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __le__(self, other)
 |      Return self<=value.
 |  
 |  __lt__(self, other)
 |      Return self<value.
 |  
 |  __ne__(self, other)
 |      Return self!=value.
 |  
 |  __setitem__(self, index, x)
 |  
 |  check_format(self, full_check=True)
 |      check whether the matrix format is valid
 |      
 |      Parameters
 |      ----------
 |      full_check : bool, optional
 |          If `True`, rigorous check, O(N) operations. Otherwise
 |          basic check, O(1) operations (default True).
 |  
 |  diagonal(self, k=0)
 |      Returns the k-th diagonal of the matrix.
 |      
 |      Parameters
 |      ----------
 |      k : int, optional
 |          Which diagonal to set, corresponding to elements a[i, i+k].
 |          Default: 0 (the main diagonal).
 |      
 |          .. versionadded:: 1.0
 |      
 |      See also
 |      --------
 |      numpy.diagonal : Equivalent numpy function.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> A.diagonal()
 |      array([1, 0, 5])
 |      >>> A.diagonal(k=1)
 |      array([2, 3])
 |  
 |  eliminate_zeros(self)
 |      Remove zero entries from the matrix
 |      
 |      This is an *in place* operation
 |  
 |  getnnz(self, axis=None)
 |      Number of stored values, including explicit zeros.
 |      
 |      Parameters
 |      ----------
 |      axis : None, 0, or 1
 |          Select between the number of values across the whole matrix, in
 |          each column, or in each row.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  maximum(self, other)
 |      Element-wise maximum between this and another matrix.
 |  
 |  minimum(self, other)
 |      Element-wise minimum between this and another matrix.
 |  
 |  multiply(self, other)
 |      Point-wise multiplication by another matrix, vector, or
 |      scalar.
 |  
 |  prune(self)
 |      Remove empty space after all non-zero elements.
 |  
 |  resize(self, *shape)
 |      Resize the matrix in-place to dimensions given by ``shape``
 |      
 |      Any elements that lie within the new shape will remain at the same
 |      indices, while non-zero elements lying outside the new shape are
 |      removed.
 |      
 |      Parameters
 |      ----------
 |      shape : (int, int)
 |          number of rows and columns in the new matrix
 |      
 |      Notes
 |      -----
 |      The semantics are not identical to `numpy.ndarray.resize` or
 |      `numpy.resize`.  Here, the same data will be maintained at each index
 |      before and after reshape, if that index is within the new bounds.  In
 |      numpy, resizing maintains contiguity of the array, moving elements
 |      around in the logical matrix but not within a flattened representation.
 |      
 |      We give no guarantees about whether the underlying data attributes
 |      (arrays, etc.) will be modified in place or replaced with new objects.
 |  
 |  sort_indices(self)
 |      Sort the indices of this matrix *in place*
 |  
 |  sorted_indices(self)
 |      Return a copy of this matrix with sorted indices
 |  
 |  sum(self, axis=None, dtype=None, out=None)
 |      Sum the matrix elements over a given axis.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the sum of all the matrix elements, returning a scalar
 |          (i.e. `axis` = `None`).
 |      dtype : dtype, optional
 |          The type of the returned matrix and of the accumulator in which
 |          the elements are summed.  The dtype of `a` is used by default
 |          unless `a` has an integer dtype of less precision than the default
 |          platform integer.  In that case, if `a` is signed then the platform
 |          integer is used while if `a` is unsigned then an unsigned integer
 |          of the same precision as the platform integer is used.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      sum_along_axis : np.matrix
 |          A matrix with the same shape as `self`, with the specified
 |          axis removed.
 |      
 |      See Also
 |      --------
 |      np.matrix.sum : NumPy's implementation of 'sum' for matrices
 |  
 |  sum_duplicates(self)
 |      Eliminate duplicate matrix entries by adding them together
 |      
 |      The is an *in place* operation
 |  
 |  toarray(self, order=None, out=None)
 |      Return a dense ndarray representation of this matrix.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F'}, optional
 |          Whether to store multi-dimensional data in C (row-major)
 |          or Fortran (column-major) order in memory. The default
 |          is 'None', indicating the NumPy default of C-ordered.
 |          Cannot be specified in conjunction with the `out`
 |          argument.
 |      
 |      out : ndarray, 2-dimensional, optional
 |          If specified, uses this array as the output buffer
 |          instead of allocating a new array to return. The provided
 |          array must have the same shape and dtype as the sparse
 |          matrix on which you are calling the method. For most
 |          sparse types, `out` is required to be memory contiguous
 |          (either C or Fortran ordered).
 |      
 |      Returns
 |      -------
 |      arr : ndarray, 2-dimensional
 |          An array with the same shape and containing the same
 |          data represented by the sparse matrix, with the requested
 |          memory order. If `out` was passed, the same object is
 |          returned after being modified in-place to contain the
 |          appropriate values.
 |  
 |  tocoo(self, copy=True)
 |      Convert this matrix to COOrdinate format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant coo_matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.compressed._cs_matrix:
 |  
 |  has_canonical_format
 |      Determine whether the matrix has sorted indices and no duplicates
 |      
 |      Returns
 |          - True: if the above applies
 |          - False: otherwise
 |      
 |      has_canonical_format implies has_sorted_indices, so if the latter flag
 |      is False, so will the former be; if the former is found True, the
 |      latter flag is also set.
 |  
 |  has_sorted_indices
 |      Determine whether the matrix has sorted indices
 |      
 |      Returns
 |          - True: if the indices of the matrix are in sorted order
 |          - False: otherwise
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.sparse.compressed._cs_matrix:
 |  
 |  __hash__ = None
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._data_matrix:
 |  
 |  __abs__(self)
 |  
 |  __imul__(self, other)
 |  
 |  __itruediv__(self, other)
 |  
 |  __neg__(self)
 |  
 |  arcsin(self)
 |      Element-wise arcsin.
 |      
 |      See numpy.arcsin for more information.
 |  
 |  arcsinh(self)
 |      Element-wise arcsinh.
 |      
 |      See numpy.arcsinh for more information.
 |  
 |  arctan(self)
 |      Element-wise arctan.
 |      
 |      See numpy.arctan for more information.
 |  
 |  arctanh(self)
 |      Element-wise arctanh.
 |      
 |      See numpy.arctanh for more information.
 |  
 |  astype(self, dtype, casting='unsafe', copy=True)
 |      Cast the matrix elements to a specified type.
 |      
 |      Parameters
 |      ----------
 |      dtype : string or numpy dtype
 |          Typecode or data-type to which to cast the data.
 |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
 |          Controls what kind of data casting may occur.
 |          Defaults to 'unsafe' for backwards compatibility.
 |          'no' means the data types should not be cast at all.
 |          'equiv' means only byte-order changes are allowed.
 |          'safe' means only casts which can preserve values are allowed.
 |          'same_kind' means only safe casts or casts within a kind,
 |          like float64 to float32, are allowed.
 |          'unsafe' means any data conversions may be done.
 |      copy : bool, optional
 |          If `copy` is `False`, the result might share some memory with this
 |          matrix. If `copy` is `True`, it is guaranteed that the result and
 |          this matrix do not share any memory.
 |  
 |  ceil(self)
 |      Element-wise ceil.
 |      
 |      See numpy.ceil for more information.
 |  
 |  conj(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  copy(self)
 |      Returns a copy of this matrix.
 |      
 |      No data/indices will be shared between the returned value and current
 |      matrix.
 |  
 |  count_nonzero(self)
 |      Number of non-zero entries, equivalent to
 |      
 |      np.count_nonzero(a.toarray())
 |      
 |      Unlike getnnz() and the nnz property, which return the number of stored
 |      entries (the length of the data attribute), this method counts the
 |      actual number of non-zero entries in data.
 |  
 |  deg2rad(self)
 |      Element-wise deg2rad.
 |      
 |      See numpy.deg2rad for more information.
 |  
 |  expm1(self)
 |      Element-wise expm1.
 |      
 |      See numpy.expm1 for more information.
 |  
 |  floor(self)
 |      Element-wise floor.
 |      
 |      See numpy.floor for more information.
 |  
 |  log1p(self)
 |      Element-wise log1p.
 |      
 |      See numpy.log1p for more information.
 |  
 |  power(self, n, dtype=None)
 |      This function performs element-wise power.
 |      
 |      Parameters
 |      ----------
 |      n : n is a scalar
 |      
 |      dtype : If dtype is not specified, the current dtype will be preserved.
 |  
 |  rad2deg(self)
 |      Element-wise rad2deg.
 |      
 |      See numpy.rad2deg for more information.
 |  
 |  rint(self)
 |      Element-wise rint.
 |      
 |      See numpy.rint for more information.
 |  
 |  sign(self)
 |      Element-wise sign.
 |      
 |      See numpy.sign for more information.
 |  
 |  sin(self)
 |      Element-wise sin.
 |      
 |      See numpy.sin for more information.
 |  
 |  sinh(self)
 |      Element-wise sinh.
 |      
 |      See numpy.sinh for more information.
 |  
 |  sqrt(self)
 |      Element-wise sqrt.
 |      
 |      See numpy.sqrt for more information.
 |  
 |  tan(self)
 |      Element-wise tan.
 |      
 |      See numpy.tan for more information.
 |  
 |  tanh(self)
 |      Element-wise tanh.
 |      
 |      See numpy.tanh for more information.
 |  
 |  trunc(self)
 |      Element-wise trunc.
 |      
 |      See numpy.trunc for more information.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.data._data_matrix:
 |  
 |  dtype
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.base.spmatrix:
 |  
 |  __add__(self, other)
 |  
 |  __bool__(self)
 |  
 |  __div__(self, other)
 |  
 |  __getattr__(self, attr)
 |  
 |  __iadd__(self, other)
 |  
 |  __idiv__(self, other)
 |  
 |  __isub__(self, other)
 |  
 |  __len__(self)
 |      # What should len(sparse) return? For consistency with dense matrices,
 |      # perhaps it should be the number of rows?  But for some uses the number of
 |      # non-zeros is more important.  For now, raise an exception!
 |  
 |  __matmul__(self, other)
 |  
 |  __mul__(self, other)
 |      interpret other and call one of the following
 |      
 |      self._mul_scalar()
 |      self._mul_vector()
 |      self._mul_multivector()
 |      self._mul_sparse_matrix()
 |  
 |  __nonzero__ = __bool__(self)
 |  
 |  __pow__(self, other)
 |  
 |  __radd__(self, other)
 |  
 |  __rdiv__(self, other)
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __rmatmul__(self, other)
 |  
 |  __rmul__(self, other)
 |  
 |  __rsub__(self, other)
 |  
 |  __rtruediv__(self, other)
 |  
 |  __str__(self)
 |      Return str(self).
 |  
 |  __sub__(self, other)
 |  
 |  __truediv__(self, other)
 |  
 |  asformat(self, format, copy=False)
 |      Return this matrix in the passed sparse format.
 |      
 |      Parameters
 |      ----------
 |      format : {str, None}
 |          The desired sparse matrix format (""csr"", ""csc"", ""lil"", ""dok"", ...)
 |          or None for no conversion.
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : This matrix in the passed sparse format.
 |  
 |  asfptype(self)
 |      Upcast matrix to a floating point format (if necessary)
 |  
 |  conjugate(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  dot(self, other)
 |      Ordinary dot product
 |      
 |      Examples
 |      --------
 |      >>> import numpy as np
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> v = np.array([1, 0, -1])
 |      >>> A.dot(v)
 |      array([ 1, -3, -1], dtype=int64)
 |  
 |  getH(self)
 |      Return the Hermitian transpose of this matrix.
 |      
 |      See Also
 |      --------
 |      np.matrix.getH : NumPy's implementation of `getH` for matrices
 |  
 |  get_shape(self)
 |      Get shape of a matrix.
 |  
 |  getformat(self)
 |      Format of a matrix representation as a string.
 |  
 |  getmaxprint(self)
 |      Maximum number of elements to display when printed.
 |  
 |  mean(self, axis=None, dtype=None, out=None)
 |      Compute the arithmetic mean along the specified axis.
 |      
 |      Returns the average of the matrix elements. The average is taken
 |      over all elements in the matrix by default, otherwise over the
 |      specified axis. `float64` intermediate and return values are used
 |      for integer inputs.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the mean is computed. The default is to compute
 |          the mean of all elements in the matrix (i.e. `axis` = `None`).
 |      dtype : data-type, optional
 |          Type to use in computing the mean. For integer inputs, the default
 |          is `float64`; for floating point inputs, it is the same as the
 |          input dtype.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      m : np.matrix
 |      
 |      See Also
 |      --------
 |      np.matrix.mean : NumPy's implementation of 'mean' for matrices
 |  
 |  reshape(self, *args, **kwargs)
 |      reshape(self, shape, order='C', copy=False)
 |      
 |      Gives a new shape to a sparse matrix without changing its data.
 |      
 |      Parameters
 |      ----------
 |      shape : length-2 tuple of ints
 |          The new shape should be compatible with the original shape.
 |      order : {'C', 'F'}, optional
 |          Read the elements using this index order. 'C' means to read and
 |          write the elements using C-like index order; e.g. read entire first
 |          row, then second row, etc. 'F' means to read and write the elements
 |          using Fortran-like index order; e.g. read entire first column, then
 |          second column, etc.
 |      copy : bool, optional
 |          Indicates whether or not attributes of self should be copied
 |          whenever possible. The degree to which attributes are copied varies
 |          depending on the type of sparse matrix being used.
 |      
 |      Returns
 |      -------
 |      reshaped_matrix : sparse matrix
 |          A sparse matrix with the given `shape`, not necessarily of the same
 |          format as the current object.
 |      
 |      See Also
 |      --------
 |      np.matrix.reshape : NumPy's implementation of 'reshape' for matrices
 |  
 |  set_shape(self, shape)
 |      See `reshape`.
 |  
 |  setdiag(self, values, k=0)
 |      Set diagonal or off-diagonal elements of the array.
 |      
 |      Parameters
 |      ----------
 |      values : array_like
 |          New values of the diagonal elements.
 |      
 |          Values may have any length.  If the diagonal is longer than values,
 |          then the remaining diagonal entries will not be set.  If values if
 |          longer than the diagonal, then the remaining values are ignored.
 |      
 |          If a scalar value is given, all of the diagonal is set to it.
 |      
 |      k : int, optional
 |          Which off-diagonal to set, corresponding to elements a[i,i+k].
 |          Default: 0 (the main diagonal).
 |  
 |  tobsr(self, blocksize=None, copy=False)
 |      Convert this matrix to Block Sparse Row format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant bsr_matrix.
 |      
 |      When blocksize=(R, C) is provided, it will be used for construction of
 |      the bsr_matrix.
 |  
 |  todense(self, order=None, out=None)
 |      Return a dense matrix representation of this matrix.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F'}, optional
 |          Whether to store multi-dimensional data in C (row-major)
 |          or Fortran (column-major) order in memory. The default
 |          is 'None', indicating the NumPy default of C-ordered.
 |          Cannot be specified in conjunction with the `out`
 |          argument.
 |      
 |      out : ndarray, 2-dimensional, optional
 |          If specified, uses this array (or `numpy.matrix`) as the
 |          output buffer instead of allocating a new array to
 |          return. The provided array must have the same shape and
 |          dtype as the sparse matrix on which you are calling the
 |          method.
 |      
 |      Returns
 |      -------
 |      arr : numpy.matrix, 2-dimensional
 |          A NumPy matrix object with the same shape and containing
 |          the same data represented by the sparse matrix, with the
 |          requested memory order. If `out` was passed and was an
 |          array (rather than a `numpy.matrix`), it will be filled
 |          with the appropriate values and returned wrapped in a
 |          `numpy.matrix` object that shares the same memory.
 |  
 |  todia(self, copy=False)
 |      Convert this matrix to sparse DIAgonal format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dia_matrix.
 |  
 |  todok(self, copy=False)
 |      Convert this matrix to Dictionary Of Keys format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dok_matrix.
 |  
 |  tolil(self, copy=False)
 |      Convert this matrix to LInked List format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant lil_matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.base.spmatrix:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  nnz
 |      Number of stored values, including explicit zeros.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  shape
 |      Get shape of a matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.sparse.base.spmatrix:
 |  
 |  __array_priority__ = 10.1
 |  
 |  ndim = 2
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._minmax_mixin:
 |  
 |  argmax(self, axis=None, out=None)
 |      Return indices of maximum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several maximum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmax is computed. If None (default), index
 |          of the maximum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      ind : np.matrix or int
 |          Indices of maximum elements. If matrix, its size along `axis` is 1.
 |  
 |  argmin(self, axis=None, out=None)
 |      Return indices of minimum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several minimum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmin is computed. If None (default), index
 |          of the minimum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |       ind : np.matrix or int
 |          Indices of minimum elements. If matrix, its size along `axis` is 1.
 |  
 |  max(self, axis=None, out=None)
 |      Return the maximum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the maximum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amax : coo_matrix or scalar
 |          Maximum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      min : The minimum value of a sparse matrix along a given axis.
 |      np.matrix.max : NumPy's implementation of 'max' for matrices
 |  
 |  min(self, axis=None, out=None)
 |      Return the minimum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the minimum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amin : coo_matrix or scalar
 |          Minimum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      max : The maximum value of a sparse matrix along a given axis.
 |      np.matrix.min : NumPy's implementation of 'min' for matrices
",class,"('self', 'arg1', 'shape', 'dtype', 'copy')","(nan, nan, None, None, False)","(nan, nan, 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, arg1, shape=None, dtype=None, copy=False)',)"
scipy,1.1.0,scipy.io.matlab.mio5_utils.pycopy,io.matlab.mio5_utils,copy,"Python Library Documentation: function copy in module copy

copy(x)
    Shallow copy operation on arbitrary Python objects.
    
    See the module's __doc__ string for more info.
",function,"('(x)',)",scipy,1.1.0,scipy.io.matlab.mio5_utils.pycopy,io.matlab.mio5_utils,copy,"Python Library Documentation: function copy in module copy

copy(x)
    Shallow copy operation on arbitrary Python objects.
    
    See the module's __doc__ string for more info.
",function,"('x',)","(nan,)","(nan,)","('arg_info',)","('(x)',)"
scipy,1.1.0,scipy.io.matlab.miobase.MatFileReader,io.matlab.miobase,MatFileReader,"Python Library Documentation: class MatFileReader in module scipy.io.matlab.miobase

class MatFileReader(builtins.object)
 |  Base object for reading mat files
 |  
 |  To make this class functional, you will need to override the
 |  following methods:
 |  
 |  matrix_getter_factory   - gives object to fetch next matrix from stream
 |  guess_byte_order        - guesses file byte order from file
 |  
 |  Methods defined here:
 |  
 |  __init__(self, mat_stream, byte_order=None, mat_dtype=False, squeeze_me=False, chars_as_strings=True, matlab_compatible=False, struct_as_record=True, verify_compressed_data_integrity=True)
 |          Initializer for mat file reader
 |      
 |          mat_stream : file-like
 |              object with file API, open for reading
 |      byte_order : str or None, optional
 |         None by default, implying byte order guessed from mat
 |         file. Otherwise can be one of ('native', '=', 'little', '<',
 |         'BIG', '>').
 |      mat_dtype : bool, optional
 |         If True, return arrays in same dtype as would be loaded into
 |         MATLAB (instead of the dtype with which they are saved).
 |      squeeze_me : bool, optional
 |         Whether to squeeze unit matrix dimensions or not.
 |      chars_as_strings : bool, optional
 |         Whether to convert char arrays to string arrays.
 |      matlab_compatible : bool, optional
 |         Returns matrices as would be loaded by MATLAB (implies
 |         squeeze_me=False, chars_as_strings=False, mat_dtype=True,
 |         struct_as_record=True).
 |  
 |  end_of_stream(self)
 |  
 |  guess_byte_order(self)
 |      As we do not know what file type we have, assume native
 |  
 |  set_matlab_compatible(self)
 |      Sets options to return arrays as MATLAB loads them
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, mat_stream, byte_order=None, mat_dtype=False, squeeze_me=False, chars_as_strings=True, matlab_compatible=False, struct_as_record=True, verify_compressed_data_integrity=True)',)",scipy,1.1.0,scipy.io.matlab.miobase.MatFileReader,io.matlab.miobase,MatFileReader,"Python Library Documentation: class MatFileReader in module scipy.io.matlab.miobase

class MatFileReader(builtins.object)
 |  Base object for reading mat files
 |  
 |  To make this class functional, you will need to override the
 |  following methods:
 |  
 |  matrix_getter_factory   - gives object to fetch next matrix from stream
 |  guess_byte_order        - guesses file byte order from file
 |  
 |  Methods defined here:
 |  
 |  __init__(self, mat_stream, byte_order=None, mat_dtype=False, squeeze_me=False, chars_as_strings=True, matlab_compatible=False, struct_as_record=True, verify_compressed_data_integrity=True)
 |          Initializer for mat file reader
 |      
 |          mat_stream : file-like
 |              object with file API, open for reading
 |      byte_order : str or None, optional
 |         None by default, implying byte order guessed from mat
 |         file. Otherwise can be one of ('native', '=', 'little', '<',
 |         'BIG', '>').
 |      mat_dtype : bool, optional
 |         If True, return arrays in same dtype as would be loaded into
 |         MATLAB (instead of the dtype with which they are saved).
 |      squeeze_me : bool, optional
 |         Whether to squeeze unit matrix dimensions or not.
 |      chars_as_strings : bool, optional
 |         Whether to convert char arrays to string arrays.
 |      matlab_compatible : bool, optional
 |         Returns matrices as would be loaded by MATLAB (implies
 |         squeeze_me=False, chars_as_strings=False, mat_dtype=True,
 |         struct_as_record=True).
 |  
 |  end_of_stream(self)
 |  
 |  guess_byte_order(self)
 |      As we do not know what file type we have, assume native
 |  
 |  set_matlab_compatible(self)
 |      Sets options to return arrays as MATLAB loads them
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'mat_stream', 'byte_order', 'mat_dtype', 'squeeze_me', 'chars_as_strings', 'matlab_compatible', 'struct_as_record', 'verify_compressed_data_integrity')","(nan, nan, None, False, False, True, False, True, True)","(nan, nan, 'NoneType', 'bool', 'bool', 'bool', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, mat_stream, byte_order=None, mat_dtype=False, squeeze_me=False, chars_as_strings=True, matlab_compatible=False, struct_as_record=True, verify_compressed_data_integrity=True)',)"
scipy,1.1.0,scipy.io.matlab.miobase.MatReadError,io.matlab.miobase,MatReadError,"Python Library Documentation: class MatReadError in module scipy.io.matlab.miobase

class MatReadError(builtins.Exception)
 |  Common base class for all non-exit exceptions.
 |  
 |  Method resolution order:
 |      MatReadError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.matlab.miobase.MatReadError,io.matlab.miobase,MatReadError,"Python Library Documentation: class MatReadError in module scipy.io.matlab.miobase

class MatReadError(builtins.Exception)
 |  Common base class for all non-exit exceptions.
 |  
 |  Method resolution order:
 |      MatReadError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.matlab.miobase.MatReadWarning,io.matlab.miobase,MatReadWarning,"Python Library Documentation: class MatReadWarning in module scipy.io.matlab.miobase

class MatReadWarning(builtins.UserWarning)
 |  Base class for warnings generated by user code.
 |  
 |  Method resolution order:
 |      MatReadWarning
 |      builtins.UserWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.UserWarning:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.matlab.miobase.MatReadWarning,io.matlab.miobase,MatReadWarning,"Python Library Documentation: class MatReadWarning in module scipy.io.matlab.miobase

class MatReadWarning(builtins.UserWarning)
 |  Base class for warnings generated by user code.
 |  
 |  Method resolution order:
 |      MatReadWarning
 |      builtins.UserWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.UserWarning:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.matlab.miobase.MatVarReader,io.matlab.miobase,MatVarReader,"Python Library Documentation: class MatVarReader in module scipy.io.matlab.miobase

class MatVarReader(builtins.object)
 |  Abstract class defining required interface for var readers
 |  
 |  Methods defined here:
 |  
 |  __init__(self, file_reader)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  array_from_header(self, header)
 |      Reads array given header
 |  
 |  read_header(self)
 |      Returns header
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, file_reader)',)",scipy,1.1.0,scipy.io.matlab.miobase.MatVarReader,io.matlab.miobase,MatVarReader,"Python Library Documentation: class MatVarReader in module scipy.io.matlab.miobase

class MatVarReader(builtins.object)
 |  Abstract class defining required interface for var readers
 |  
 |  Methods defined here:
 |  
 |  __init__(self, file_reader)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  array_from_header(self, header)
 |      Reads array given header
 |  
 |  read_header(self)
 |      Returns header
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'file_reader')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(self, file_reader)',)"
scipy,1.1.0,scipy.io.matlab.miobase.MatWriteError,io.matlab.miobase,MatWriteError,"Python Library Documentation: class MatWriteError in module scipy.io.matlab.miobase

class MatWriteError(builtins.Exception)
 |  Common base class for all non-exit exceptions.
 |  
 |  Method resolution order:
 |      MatWriteError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.matlab.miobase.MatWriteError,io.matlab.miobase,MatWriteError,"Python Library Documentation: class MatWriteError in module scipy.io.matlab.miobase

class MatWriteError(builtins.Exception)
 |  Common base class for all non-exit exceptions.
 |  
 |  Method resolution order:
 |      MatWriteError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.matlab.miobase.arr_dtype_number,io.matlab.miobase,arr_dtype_number,"Python Library Documentation: function arr_dtype_number in module scipy.io.matlab.miobase

arr_dtype_number(arr, num)
    Return dtype for given number of items per element
",function,"('(arr, num)',)",scipy,1.1.0,scipy.io.matlab.miobase.arr_dtype_number,io.matlab.miobase,arr_dtype_number,"Python Library Documentation: function arr_dtype_number in module scipy.io.matlab.miobase

arr_dtype_number(arr, num)
    Return dtype for given number of items per element
",function,"('arr', 'num')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(arr, num)',)"
scipy,1.1.0,scipy.io.matlab.miobase.arr_to_chars,io.matlab.miobase,arr_to_chars,"Python Library Documentation: function arr_to_chars in module scipy.io.matlab.miobase

arr_to_chars(arr)
    Convert string array to char array
",function,"('(arr)',)",scipy,1.1.0,scipy.io.matlab.miobase.arr_to_chars,io.matlab.miobase,arr_to_chars,"Python Library Documentation: function arr_to_chars in module scipy.io.matlab.miobase

arr_to_chars(arr)
    Convert string array to char array
",function,"('arr',)","(nan,)","(nan,)","('arg_info',)","('(arr)',)"
scipy,1.1.0,scipy.io.matlab.miobase.byteord,io.matlab.miobase,int,"Python Library Documentation: class int in module builtins

class int(object)
 |  int(x=0) -> integer
 |  int(x, base=10) -> integer
 |  
 |  Convert a number or string to an integer, or return 0 if no arguments
 |  are given.  If x is a number, return x.__int__().  For floating point
 |  numbers, this truncates towards zero.
 |  
 |  If x is not a number or if base is given, then x must be a string,
 |  bytes, or bytearray instance representing an integer literal in the
 |  given base.  The literal can be preceded by '+' or '-' and be surrounded
 |  by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
 |  Base 0 means to interpret the base from the string as an integer literal.
 |  >>> int('0b100', base=0)
 |  4
 |  
 |  Methods defined here:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __ceil__(...)
 |      Ceiling of an Integral returns itself.
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floor__(...)
 |      Flooring an Integral returns itself.
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __format__(...)
 |      default object formatter
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getnewargs__(...)
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __round__(...)
 |      Rounding an Integral returns itself.
 |      Rounding with an ndigits argument also returns an integer.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __sizeof__(...)
 |      Returns size in memory, in bytes
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  bit_length(...)
 |      int.bit_length() -> int
 |      
 |      Number of bits necessary to represent self in binary.
 |      >>> bin(37)
 |      '0b100101'
 |      >>> (37).bit_length()
 |      6
 |  
 |  conjugate(...)
 |      Returns self, the complex conjugate of any int.
 |  
 |  from_bytes(...) from builtins.type
 |      int.from_bytes(bytes, byteorder, *, signed=False) -> int
 |      
 |      Return the integer represented by the given array of bytes.
 |      
 |      The bytes argument must be a bytes-like object (e.g. bytes or bytearray).
 |      
 |      The byteorder argument determines the byte order used to represent the
 |      integer.  If byteorder is 'big', the most significant byte is at the
 |      beginning of the byte array.  If byteorder is 'little', the most
 |      significant byte is at the end of the byte array.  To request the native
 |      byte order of the host system, use `sys.byteorder' as the byte order value.
 |      
 |      The signed keyword-only argument indicates whether two's complement is
 |      used to represent the integer.
 |  
 |  to_bytes(...)
 |      int.to_bytes(length, byteorder, *, signed=False) -> bytes
 |      
 |      Return an array of bytes representing an integer.
 |      
 |      The integer is represented using length bytes.  An OverflowError is
 |      raised if the integer is not representable with the given number of
 |      bytes.
 |      
 |      The byteorder argument determines the byte order used to represent the
 |      integer.  If byteorder is 'big', the most significant byte is at the
 |      beginning of the byte array.  If byteorder is 'little', the most
 |      significant byte is at the end of the byte array.  To request the native
 |      byte order of the host system, use `sys.byteorder' as the byte order value.
 |      
 |      The signed keyword-only argument determines whether two's complement is
 |      used to represent the integer.  If signed is False and a negative integer
 |      is given, an OverflowError is raised.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  denominator
 |      the denominator of a rational number in lowest terms
 |  
 |  imag
 |      the imaginary part of a complex number
 |  
 |  numerator
 |      the numerator of a rational number in lowest terms
 |  
 |  real
 |      the real part of a complex number
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.matlab.miobase.byteord,io.matlab.miobase,int,"Python Library Documentation: class int in module builtins

class int(object)
 |  int(x=0) -> integer
 |  int(x, base=10) -> integer
 |  
 |  Convert a number or string to an integer, or return 0 if no arguments
 |  are given.  If x is a number, return x.__int__().  For floating point
 |  numbers, this truncates towards zero.
 |  
 |  If x is not a number or if base is given, then x must be a string,
 |  bytes, or bytearray instance representing an integer literal in the
 |  given base.  The literal can be preceded by '+' or '-' and be surrounded
 |  by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
 |  Base 0 means to interpret the base from the string as an integer literal.
 |  >>> int('0b100', base=0)
 |  4
 |  
 |  Methods defined here:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __ceil__(...)
 |      Ceiling of an Integral returns itself.
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floor__(...)
 |      Flooring an Integral returns itself.
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __format__(...)
 |      default object formatter
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getnewargs__(...)
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __round__(...)
 |      Rounding an Integral returns itself.
 |      Rounding with an ndigits argument also returns an integer.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __sizeof__(...)
 |      Returns size in memory, in bytes
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  bit_length(...)
 |      int.bit_length() -> int
 |      
 |      Number of bits necessary to represent self in binary.
 |      >>> bin(37)
 |      '0b100101'
 |      >>> (37).bit_length()
 |      6
 |  
 |  conjugate(...)
 |      Returns self, the complex conjugate of any int.
 |  
 |  from_bytes(...) from builtins.type
 |      int.from_bytes(bytes, byteorder, *, signed=False) -> int
 |      
 |      Return the integer represented by the given array of bytes.
 |      
 |      The bytes argument must be a bytes-like object (e.g. bytes or bytearray).
 |      
 |      The byteorder argument determines the byte order used to represent the
 |      integer.  If byteorder is 'big', the most significant byte is at the
 |      beginning of the byte array.  If byteorder is 'little', the most
 |      significant byte is at the end of the byte array.  To request the native
 |      byte order of the host system, use `sys.byteorder' as the byte order value.
 |      
 |      The signed keyword-only argument indicates whether two's complement is
 |      used to represent the integer.
 |  
 |  to_bytes(...)
 |      int.to_bytes(length, byteorder, *, signed=False) -> bytes
 |      
 |      Return an array of bytes representing an integer.
 |      
 |      The integer is represented using length bytes.  An OverflowError is
 |      raised if the integer is not representable with the given number of
 |      bytes.
 |      
 |      The byteorder argument determines the byte order used to represent the
 |      integer.  If byteorder is 'big', the most significant byte is at the
 |      beginning of the byte array.  If byteorder is 'little', the most
 |      significant byte is at the end of the byte array.  To request the native
 |      byte order of the host system, use `sys.byteorder' as the byte order value.
 |      
 |      The signed keyword-only argument determines whether two's complement is
 |      used to represent the integer.  If signed is False and a negative integer
 |      is given, an OverflowError is raised.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  denominator
 |      the denominator of a rational number in lowest terms
 |  
 |  imag
 |      the imaginary part of a complex number
 |  
 |  numerator
 |      the numerator of a rational number in lowest terms
 |  
 |  real
 |      the real part of a complex number
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.matlab.miobase.convert_dtypes,io.matlab.miobase,convert_dtypes,"Python Library Documentation: function convert_dtypes in module scipy.io.matlab.miobase

convert_dtypes(dtype_template, order_code)
    Convert dtypes in mapping to given order
    
    Parameters
    ----------
    dtype_template : mapping
       mapping with values returning numpy dtype from ``np.dtype(val)``
    order_code : str
       an order code suitable for using in ``dtype.newbyteorder()``
    
    Returns
    -------
    dtypes : mapping
       mapping where values have been replaced by
       ``np.dtype(val).newbyteorder(order_code)``
",function,"('(dtype_template, order_code)',)",scipy,1.1.0,scipy.io.matlab.miobase.convert_dtypes,io.matlab.miobase,convert_dtypes,"Python Library Documentation: function convert_dtypes in module scipy.io.matlab.miobase

convert_dtypes(dtype_template, order_code)
    Convert dtypes in mapping to given order
    
    Parameters
    ----------
    dtype_template : mapping
       mapping with values returning numpy dtype from ``np.dtype(val)``
    order_code : str
       an order code suitable for using in ``dtype.newbyteorder()``
    
    Returns
    -------
    dtypes : mapping
       mapping where values have been replaced by
       ``np.dtype(val).newbyteorder(order_code)``
",function,"('dtype_template', 'order_code')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(dtype_template, order_code)',)"
scipy,1.1.0,scipy.io.matlab.miobase.docfiller,io.matlab.miobase,decorate,"Python Library Documentation: function decorate in module scipy.misc.doccer

decorate(f)
",function,"('(f)',)",scipy,1.1.0,scipy.io.matlab.miobase.docfiller,io.matlab.miobase,decorate,"Python Library Documentation: function decorate in module scipy.misc.doccer

decorate(f)
",function,"('f',)","(nan,)","(nan,)","('arg_info',)","('(f)',)"
scipy,1.1.0,scipy.io.matlab.miobase.get_matfile_version,io.matlab.miobase,get_matfile_version,"Python Library Documentation: function get_matfile_version in module scipy.io.matlab.miobase

get_matfile_version(fileobj)
    Return major, minor tuple depending on apparent mat file type
    
    Where:
    
     #. 0,x -> version 4 format mat files
     #. 1,x -> version 5 format mat files
     #. 2,x -> version 7.3 format mat files (HDF format)
    
    Parameters
    ----------
    fileobj : file_like
        object implementing seek() and read()
    
    Returns
    -------
    major_version : {0, 1, 2}
        major MATLAB File format version
    minor_version : int
        minor MATLAB file format version
    
    Raises
    ------
    MatReadError
        If the file is empty.
    ValueError
        The matfile version is unknown.
    
    Notes
    -----
    Has the side effect of setting the file read pointer to 0
",function,"('(fileobj)',)",scipy,1.1.0,scipy.io.matlab.miobase.get_matfile_version,io.matlab.miobase,get_matfile_version,"Python Library Documentation: function get_matfile_version in module scipy.io.matlab.miobase

get_matfile_version(fileobj)
    Return major, minor tuple depending on apparent mat file type
    
    Where:
    
     #. 0,x -> version 4 format mat files
     #. 1,x -> version 5 format mat files
     #. 2,x -> version 7.3 format mat files (HDF format)
    
    Parameters
    ----------
    fileobj : file_like
        object implementing seek() and read()
    
    Returns
    -------
    major_version : {0, 1, 2}
        major MATLAB File format version
    minor_version : int
        minor MATLAB file format version
    
    Raises
    ------
    MatReadError
        If the file is empty.
    ValueError
        The matfile version is unknown.
    
    Notes
    -----
    Has the side effect of setting the file read pointer to 0
",function,"('fileobj',)","(nan,)","(nan,)","('arg_info',)","('(fileobj)',)"
scipy,1.1.0,scipy.io.matlab.miobase.matdims,io.matlab.miobase,matdims,"Python Library Documentation: function matdims in module scipy.io.matlab.miobase

matdims(arr, oned_as='column')
    Determine equivalent MATLAB dimensions for given array
    
    Parameters
    ----------
    arr : ndarray
        Input array
    oned_as : {'column', 'row'}, optional
        Whether 1-D arrays are returned as MATLAB row or column matrices.
        Default is 'column'.
    
    Returns
    -------
    dims : tuple
        Shape tuple, in the form MATLAB expects it.
    
    Notes
    -----
    We had to decide what shape a 1 dimensional array would be by
    default.  ``np.atleast_2d`` thinks it is a row vector.  The
    default for a vector in MATLAB (e.g. ``>> 1:12``) is a row vector.
    
    Versions of scipy up to and including 0.11 resulted (accidentally)
    in 1-D arrays being read as column vectors.  For the moment, we
    maintain the same tradition here.
    
    Examples
    --------
    >>> matdims(np.array(1)) # numpy scalar
    (1, 1)
    >>> matdims(np.array([1])) # 1d array, 1 element
    (1, 1)
    >>> matdims(np.array([1,2])) # 1d array, 2 elements
    (2, 1)
    >>> matdims(np.array([[2],[3]])) # 2d array, column vector
    (2, 1)
    >>> matdims(np.array([[2,3]])) # 2d array, row vector
    (1, 2)
    >>> matdims(np.array([[[2,3]]])) # 3d array, rowish vector
    (1, 1, 2)
    >>> matdims(np.array([])) # empty 1d array
    (0, 0)
    >>> matdims(np.array([[]])) # empty 2d
    (0, 0)
    >>> matdims(np.array([[[]]])) # empty 3d
    (0, 0, 0)
    
    Optional argument flips 1-D shape behavior.
    
    >>> matdims(np.array([1,2]), 'row') # 1d array, 2 elements
    (1, 2)
    
    The argument has to make sense though
    
    >>> matdims(np.array([1,2]), 'bizarre')
    Traceback (most recent call last):
       ...
    ValueError: 1D option ""bizarre"" is strange
",function,"(""(arr, oned_as='column')"",)",scipy,1.1.0,scipy.io.matlab.miobase.matdims,io.matlab.miobase,matdims,"Python Library Documentation: function matdims in module scipy.io.matlab.miobase

matdims(arr, oned_as='column')
    Determine equivalent MATLAB dimensions for given array
    
    Parameters
    ----------
    arr : ndarray
        Input array
    oned_as : {'column', 'row'}, optional
        Whether 1-D arrays are returned as MATLAB row or column matrices.
        Default is 'column'.
    
    Returns
    -------
    dims : tuple
        Shape tuple, in the form MATLAB expects it.
    
    Notes
    -----
    We had to decide what shape a 1 dimensional array would be by
    default.  ``np.atleast_2d`` thinks it is a row vector.  The
    default for a vector in MATLAB (e.g. ``>> 1:12``) is a row vector.
    
    Versions of scipy up to and including 0.11 resulted (accidentally)
    in 1-D arrays being read as column vectors.  For the moment, we
    maintain the same tradition here.
    
    Examples
    --------
    >>> matdims(np.array(1)) # numpy scalar
    (1, 1)
    >>> matdims(np.array([1])) # 1d array, 1 element
    (1, 1)
    >>> matdims(np.array([1,2])) # 1d array, 2 elements
    (2, 1)
    >>> matdims(np.array([[2],[3]])) # 2d array, column vector
    (2, 1)
    >>> matdims(np.array([[2,3]])) # 2d array, row vector
    (1, 2)
    >>> matdims(np.array([[[2,3]]])) # 3d array, rowish vector
    (1, 1, 2)
    >>> matdims(np.array([])) # empty 1d array
    (0, 0)
    >>> matdims(np.array([[]])) # empty 2d
    (0, 0)
    >>> matdims(np.array([[[]]])) # empty 3d
    (0, 0, 0)
    
    Optional argument flips 1-D shape behavior.
    
    >>> matdims(np.array([1,2]), 'row') # 1d array, 2 elements
    (1, 2)
    
    The argument has to make sense though
    
    >>> matdims(np.array([1,2]), 'bizarre')
    Traceback (most recent call last):
       ...
    ValueError: 1D option ""bizarre"" is strange
",function,"('arr', 'oned_as')","(nan, 'column')","(nan, 'str')","('arg_info', 'arg_info')","(""(arr, oned_as='column')"",)"
scipy,1.1.0,scipy.io.matlab.miobase.read_dtype,io.matlab.miobase,read_dtype,"Python Library Documentation: function read_dtype in module scipy.io.matlab.miobase

read_dtype(mat_stream, a_dtype)
    Generic get of byte stream data of known type
    
    Parameters
    ----------
    mat_stream : file_like object
        MATLAB (tm) mat file stream
    a_dtype : dtype
        dtype of array to read.  `a_dtype` is assumed to be correct
        endianness.
    
    Returns
    -------
    arr : ndarray
        Array of dtype `a_dtype` read from stream.
",function,"('(mat_stream, a_dtype)',)",scipy,1.1.0,scipy.io.matlab.miobase.read_dtype,io.matlab.miobase,read_dtype,"Python Library Documentation: function read_dtype in module scipy.io.matlab.miobase

read_dtype(mat_stream, a_dtype)
    Generic get of byte stream data of known type
    
    Parameters
    ----------
    mat_stream : file_like object
        MATLAB (tm) mat file stream
    a_dtype : dtype
        dtype of array to read.  `a_dtype` is assumed to be correct
        endianness.
    
    Returns
    -------
    arr : ndarray
        Array of dtype `a_dtype` read from stream.
",function,"('mat_stream', 'a_dtype')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(mat_stream, a_dtype)',)"
scipy,1.1.0,scipy.io.matlab.savemat,io.matlab,savemat,"Python Library Documentation: function savemat in module scipy.io.matlab.mio

savemat(file_name, mdict, appendmat=True, format='5', long_field_names=False, do_compression=False, oned_as='row')
    Save a dictionary of names and arrays into a MATLAB-style .mat file.
    
    This saves the array objects in the given dictionary to a MATLAB-
    style .mat file.
    
    Parameters
    ----------
    file_name : str or file-like object
        Name of the .mat file (.mat extension not needed if ``appendmat ==
        True``).
        Can also pass open file_like object.
    mdict : dict
        Dictionary from which to save matfile variables.
    appendmat : bool, optional
        True (the default) to append the .mat extension to the end of the
        given filename, if not already present.
    format : {'5', '4'}, string, optional
        '5' (the default) for MATLAB 5 and up (to 7.2),
        '4' for MATLAB 4 .mat files.
    long_field_names : bool, optional
        False (the default) - maximum field name length in a structure is
        31 characters which is the documented maximum length.
        True - maximum field name length in a structure is 63 characters
        which works for MATLAB 7.6+.
    do_compression : bool, optional
        Whether or not to compress matrices on write.  Default is False.
    oned_as : {'row', 'column'}, optional
        If 'column', write 1-D numpy arrays as column vectors.
        If 'row', write 1-D numpy arrays as row vectors.
    
    See also
    --------
    mio4.MatFile4Writer
    mio5.MatFile5Writer
",function,"(""(file_name, mdict, appendmat=True, format='5', long_field_names=False, do_compression=False, oned_as='row')"",)",scipy,1.1.0,scipy.io.matlab.savemat,io.matlab,savemat,"Python Library Documentation: function savemat in module scipy.io.matlab.mio

savemat(file_name, mdict, appendmat=True, format='5', long_field_names=False, do_compression=False, oned_as='row')
    Save a dictionary of names and arrays into a MATLAB-style .mat file.
    
    This saves the array objects in the given dictionary to a MATLAB-
    style .mat file.
    
    Parameters
    ----------
    file_name : str or file-like object
        Name of the .mat file (.mat extension not needed if ``appendmat ==
        True``).
        Can also pass open file_like object.
    mdict : dict
        Dictionary from which to save matfile variables.
    appendmat : bool, optional
        True (the default) to append the .mat extension to the end of the
        given filename, if not already present.
    format : {'5', '4'}, string, optional
        '5' (the default) for MATLAB 5 and up (to 7.2),
        '4' for MATLAB 4 .mat files.
    long_field_names : bool, optional
        False (the default) - maximum field name length in a structure is
        31 characters which is the documented maximum length.
        True - maximum field name length in a structure is 63 characters
        which works for MATLAB 7.6+.
    do_compression : bool, optional
        Whether or not to compress matrices on write.  Default is False.
    oned_as : {'row', 'column'}, optional
        If 'column', write 1-D numpy arrays as column vectors.
        If 'row', write 1-D numpy arrays as row vectors.
    
    See also
    --------
    mio4.MatFile4Writer
    mio5.MatFile5Writer
",function,"('file_name', 'mdict', 'appendmat', 'format', 'long_field_names', 'do_compression', 'oned_as')","(nan, nan, True, '5', False, False, 'row')","(nan, nan, 'bool', 'int', 'bool', 'bool', 'str')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(file_name, mdict, appendmat=True, format='5', long_field_names=False, do_compression=False, oned_as='row')"",)"
scipy,1.1.0,scipy.io.matlab.streams.FileStream,io.matlab.streams,FileStream,"Python Library Documentation: class FileStream in module scipy.io.matlab.streams

class FileStream(GenericStream)
 |  Method resolution order:
 |      FileStream
 |      GenericStream
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __del__(...)
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__ = __reduce_cython__(...)
 |  
 |  __setstate__ = __setstate_cython__(...)
 |  
 |  seek(...)
 |  
 |  tell(...)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __pyx_vtable__ = <capsule object NULL>
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from GenericStream:
 |  
 |  read(...)
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.matlab.streams.FileStream,io.matlab.streams,FileStream,"Python Library Documentation: class FileStream in module scipy.io.matlab.streams

class FileStream(GenericStream)
 |  Method resolution order:
 |      FileStream
 |      GenericStream
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __del__(...)
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__ = __reduce_cython__(...)
 |  
 |  __setstate__ = __setstate_cython__(...)
 |  
 |  seek(...)
 |  
 |  tell(...)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __pyx_vtable__ = <capsule object NULL>
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from GenericStream:
 |  
 |  read(...)
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.matlab.streams.GenericStream,io.matlab.streams,GenericStream,"Python Library Documentation: class GenericStream in module scipy.io.matlab.streams

class GenericStream(builtins.object)
 |  Methods defined here:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__ = __reduce_cython__(...)
 |  
 |  __setstate__ = __setstate_cython__(...)
 |  
 |  read(...)
 |  
 |  seek(...)
 |  
 |  tell(...)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __pyx_vtable__ = <capsule object NULL>
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.matlab.streams.GenericStream,io.matlab.streams,GenericStream,"Python Library Documentation: class GenericStream in module scipy.io.matlab.streams

class GenericStream(builtins.object)
 |  Methods defined here:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__ = __reduce_cython__(...)
 |  
 |  __setstate__ = __setstate_cython__(...)
 |  
 |  read(...)
 |  
 |  seek(...)
 |  
 |  tell(...)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __pyx_vtable__ = <capsule object NULL>
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.matlab.streams.ZlibInputStream,io.matlab.streams,ZlibInputStream,"Python Library Documentation: class ZlibInputStream in module scipy.io.matlab.streams

class ZlibInputStream(GenericStream)
 |  File-like object uncompressing bytes from a zlib compressed stream.
 |  
 |  Parameters
 |  ----------
 |  stream : file-like
 |      Stream to read compressed data from.
 |  max_length : int
 |      Maximum number of bytes to read from the stream.
 |  
 |  Notes
 |  -----
 |  Some matlab files contain zlib streams without valid Z_STREAM_END
 |  termination.  To get round this, we use the decompressobj object, that
 |  allows you to decode an incomplete stream.  See discussion at
 |  http://bugs.python.org/issue8672
 |  
 |  Method resolution order:
 |      ZlibInputStream
 |      GenericStream
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__ = __reduce_cython__(...)
 |  
 |  __setstate__ = __setstate_cython__(...)
 |  
 |  all_data_read(...)
 |  
 |  read(...)
 |  
 |  seek(...)
 |  
 |  tell(...)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __pyx_vtable__ = <capsule object NULL>
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.matlab.streams.ZlibInputStream,io.matlab.streams,ZlibInputStream,"Python Library Documentation: class ZlibInputStream in module scipy.io.matlab.streams

class ZlibInputStream(GenericStream)
 |  File-like object uncompressing bytes from a zlib compressed stream.
 |  
 |  Parameters
 |  ----------
 |  stream : file-like
 |      Stream to read compressed data from.
 |  max_length : int
 |      Maximum number of bytes to read from the stream.
 |  
 |  Notes
 |  -----
 |  Some matlab files contain zlib streams without valid Z_STREAM_END
 |  termination.  To get round this, we use the decompressobj object, that
 |  allows you to decode an incomplete stream.  See discussion at
 |  http://bugs.python.org/issue8672
 |  
 |  Method resolution order:
 |      ZlibInputStream
 |      GenericStream
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__ = __reduce_cython__(...)
 |  
 |  __setstate__ = __setstate_cython__(...)
 |  
 |  all_data_read(...)
 |  
 |  read(...)
 |  
 |  seek(...)
 |  
 |  tell(...)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __pyx_vtable__ = <capsule object NULL>
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.matlab.streams.cStringStream,io.matlab.streams,cStringStream,"Python Library Documentation: class cStringStream in module scipy.io.matlab.streams

class cStringStream(GenericStream)
 |  Method resolution order:
 |      cStringStream
 |      GenericStream
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__ = __reduce_cython__(...)
 |  
 |  __setstate__ = __setstate_cython__(...)
 |  
 |  seek(...)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __pyx_vtable__ = <capsule object NULL>
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from GenericStream:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  read(...)
 |  
 |  tell(...)
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.matlab.streams.cStringStream,io.matlab.streams,cStringStream,"Python Library Documentation: class cStringStream in module scipy.io.matlab.streams

class cStringStream(GenericStream)
 |  Method resolution order:
 |      cStringStream
 |      GenericStream
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__ = __reduce_cython__(...)
 |  
 |  __setstate__ = __setstate_cython__(...)
 |  
 |  seek(...)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __pyx_vtable__ = <capsule object NULL>
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from GenericStream:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  read(...)
 |  
 |  tell(...)
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.matlab.whosmat,io.matlab,whosmat,"Python Library Documentation: function whosmat in module scipy.io.matlab.mio

whosmat(file_name, appendmat=True, **kwargs)
    List variables inside a MATLAB file.
    
    Parameters
    ----------
    file_name : str
       Name of the mat file (do not need .mat extension if
       appendmat==True) Can also pass open file-like object.
    appendmat : bool, optional
       True to append the .mat extension to the end of the given
       filename, if not already present.
    byte_order : str or None, optional
       None by default, implying byte order guessed from mat
       file. Otherwise can be one of ('native', '=', 'little', '<',
       'BIG', '>').
    mat_dtype : bool, optional
       If True, return arrays in same dtype as would be loaded into
       MATLAB (instead of the dtype with which they are saved).
    squeeze_me : bool, optional
       Whether to squeeze unit matrix dimensions or not.
    chars_as_strings : bool, optional
       Whether to convert char arrays to string arrays.
    matlab_compatible : bool, optional
       Returns matrices as would be loaded by MATLAB (implies
       squeeze_me=False, chars_as_strings=False, mat_dtype=True,
       struct_as_record=True).
    struct_as_record : bool, optional
       Whether to load MATLAB structs as numpy record arrays, or as
       old-style numpy arrays with dtype=object.  Setting this flag to
       False replicates the behavior of scipy version 0.7.x (returning
       numpy object arrays).  The default setting is True, because it
       allows easier round-trip load and save of MATLAB files.
    
    Returns
    -------
    variables : list of tuples
        A list of tuples, where each tuple holds the matrix name (a string),
        its shape (tuple of ints), and its data class (a string).
        Possible data classes are: int8, uint8, int16, uint16, int32, uint32,
        int64, uint64, single, double, cell, struct, object, char, sparse,
        function, opaque, logical, unknown.
    
    Notes
    -----
    v4 (Level 1.0), v6 and v7 to 7.2 matfiles are supported.
    
    You will need an HDF5 python library to read matlab 7.3 format mat
    files.  Because scipy does not supply one, we do not implement the
    HDF5 / 7.3 interface here.
    
    .. versionadded:: 0.12.0
",function,"('(file_name, appendmat=True, **kwargs)',)",scipy,1.1.0,scipy.io.matlab.whosmat,io.matlab,whosmat,"Python Library Documentation: function whosmat in module scipy.io.matlab.mio

whosmat(file_name, appendmat=True, **kwargs)
    List variables inside a MATLAB file.
    
    Parameters
    ----------
    file_name : str
       Name of the mat file (do not need .mat extension if
       appendmat==True) Can also pass open file-like object.
    appendmat : bool, optional
       True to append the .mat extension to the end of the given
       filename, if not already present.
    byte_order : str or None, optional
       None by default, implying byte order guessed from mat
       file. Otherwise can be one of ('native', '=', 'little', '<',
       'BIG', '>').
    mat_dtype : bool, optional
       If True, return arrays in same dtype as would be loaded into
       MATLAB (instead of the dtype with which they are saved).
    squeeze_me : bool, optional
       Whether to squeeze unit matrix dimensions or not.
    chars_as_strings : bool, optional
       Whether to convert char arrays to string arrays.
    matlab_compatible : bool, optional
       Returns matrices as would be loaded by MATLAB (implies
       squeeze_me=False, chars_as_strings=False, mat_dtype=True,
       struct_as_record=True).
    struct_as_record : bool, optional
       Whether to load MATLAB structs as numpy record arrays, or as
       old-style numpy arrays with dtype=object.  Setting this flag to
       False replicates the behavior of scipy version 0.7.x (returning
       numpy object arrays).  The default setting is True, because it
       allows easier round-trip load and save of MATLAB files.
    
    Returns
    -------
    variables : list of tuples
        A list of tuples, where each tuple holds the matrix name (a string),
        its shape (tuple of ints), and its data class (a string).
        Possible data classes are: int8, uint8, int16, uint16, int32, uint32,
        int64, uint64, single, double, cell, struct, object, char, sparse,
        function, opaque, logical, unknown.
    
    Notes
    -----
    v4 (Level 1.0), v6 and v7 to 7.2 matfiles are supported.
    
    You will need an HDF5 python library to read matlab 7.3 format mat
    files.  Because scipy does not supply one, we do not implement the
    HDF5 / 7.3 interface here.
    
    .. versionadded:: 0.12.0
",function,"('file_name', 'appendmat')","(nan, True)","(nan, 'bool')","('arg_info', 'arg_info')","('(file_name, appendmat=True, **kwargs)',)"
scipy,1.1.0,scipy.io.mminfo,io,mminfo,"Python Library Documentation: function mminfo in module scipy.io.mmio

mminfo(source)
    Return size and storage parameters from Matrix Market file-like 'source'.
    
    Parameters
    ----------
    source : str or file-like
        Matrix Market filename (extension .mtx) or open file-like object
    
    Returns
    -------
    rows : int
        Number of matrix rows.
    cols : int
        Number of matrix columns.
    entries : int
        Number of non-zero entries of a sparse matrix
        or rows*cols for a dense matrix.
    format : str
        Either 'coordinate' or 'array'.
    field : str
        Either 'real', 'complex', 'pattern', or 'integer'.
    symmetry : str
        Either 'general', 'symmetric', 'skew-symmetric', or 'hermitian'.
",function,"('(source)',)",scipy,1.1.0,scipy.io.mminfo,io,mminfo,"Python Library Documentation: function mminfo in module scipy.io.mmio

mminfo(source)
    Return size and storage parameters from Matrix Market file-like 'source'.
    
    Parameters
    ----------
    source : str or file-like
        Matrix Market filename (extension .mtx) or open file-like object
    
    Returns
    -------
    rows : int
        Number of matrix rows.
    cols : int
        Number of matrix columns.
    entries : int
        Number of non-zero entries of a sparse matrix
        or rows*cols for a dense matrix.
    format : str
        Either 'coordinate' or 'array'.
    field : str
        Either 'real', 'complex', 'pattern', or 'integer'.
    symmetry : str
        Either 'general', 'symmetric', 'skew-symmetric', or 'hermitian'.
",function,"('source',)","(nan,)","(nan,)","('arg_info',)","('(source)',)"
scipy,1.1.0,scipy.io.mmio.MMFile,io.mmio,MMFile,"Python Library Documentation: class MMFile in module scipy.io.mmio

class MMFile(builtins.object)
 |  ###############################################################################
 |  
 |  Methods defined here:
 |  
 |  __init__(self, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  read(self, source)
 |      Reads the contents of a Matrix Market file-like 'source' into a matrix.
 |      
 |      Parameters
 |      ----------
 |      source : str or file-like
 |          Matrix Market filename (extensions .mtx, .mtz.gz)
 |          or open file object.
 |      
 |      Returns
 |      -------
 |      a : ndarray or coo_matrix
 |          Dense or sparse matrix depending on the matrix format in the
 |          Matrix Market file.
 |  
 |  write(self, target, a, comment='', field=None, precision=None, symmetry=None)
 |      Writes sparse or dense array `a` to Matrix Market file-like `target`.
 |      
 |      Parameters
 |      ----------
 |      target : str or file-like
 |          Matrix Market filename (extension .mtx) or open file-like object.
 |      a : array like
 |          Sparse or dense 2D array.
 |      comment : str, optional
 |          Comments to be prepended to the Matrix Market file.
 |      field : None or str, optional
 |          Either 'real', 'complex', 'pattern', or 'integer'.
 |      precision : None or int, optional
 |          Number of digits to display for real or complex values.
 |      symmetry : None or str, optional
 |          Either 'general', 'symmetric', 'skew-symmetric', or 'hermitian'.
 |          If symmetry is None the symmetry type of 'a' is determined by its
 |          values.
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  info(source) from builtins.type
 |      Return size, storage parameters from Matrix Market file-like 'source'.
 |      
 |      Parameters
 |      ----------
 |      source : str or file-like
 |          Matrix Market filename (extension .mtx) or open file-like object
 |      
 |      Returns
 |      -------
 |      rows : int
 |          Number of matrix rows.
 |      cols : int
 |          Number of matrix columns.
 |      entries : int
 |          Number of non-zero entries of a sparse matrix
 |          or rows*cols for a dense matrix.
 |      format : str
 |          Either 'coordinate' or 'array'.
 |      field : str
 |          Either 'real', 'complex', 'pattern', or 'integer'.
 |      symmetry : str
 |          Either 'general', 'symmetric', 'skew-symmetric', or 'hermitian'.
 |  
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |  
 |  reader()
 |      # -------------------------------------------------------------------------
 |  
 |  writer()
 |      # -------------------------------------------------------------------------
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  cols
 |  
 |  entries
 |  
 |  field
 |  
 |  format
 |  
 |  has_symmetry
 |  
 |  rows
 |  
 |  symmetry
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  DTYPES_BY_FIELD = {'complex': 'D', 'integer': 'intp', 'pattern': 'd', ...
 |  
 |  FIELD_COMPLEX = 'complex'
 |  
 |  FIELD_INTEGER = 'integer'
 |  
 |  FIELD_PATTERN = 'pattern'
 |  
 |  FIELD_REAL = 'real'
 |  
 |  FIELD_UNSIGNED = 'unsigned-integer'
 |  
 |  FIELD_VALUES = ('integer', 'unsigned-integer', 'real', 'complex', 'pat...
 |  
 |  FORMAT_ARRAY = 'array'
 |  
 |  FORMAT_COORDINATE = 'coordinate'
 |  
 |  FORMAT_VALUES = ('coordinate', 'array')
 |  
 |  SYMMETRY_GENERAL = 'general'
 |  
 |  SYMMETRY_HERMITIAN = 'hermitian'
 |  
 |  SYMMETRY_SKEW_SYMMETRIC = 'skew-symmetric'
 |  
 |  SYMMETRY_SYMMETRIC = 'symmetric'
 |  
 |  SYMMETRY_VALUES = ('general', 'symmetric', 'skew-symmetric', 'hermitia...
",class,"('(self, **kwargs)',)",scipy,1.1.0,scipy.io.mmio.MMFile,io.mmio,MMFile,"Python Library Documentation: class MMFile in module scipy.io.mmio

class MMFile(builtins.object)
 |  ###############################################################################
 |  
 |  Methods defined here:
 |  
 |  __init__(self, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  read(self, source)
 |      Reads the contents of a Matrix Market file-like 'source' into a matrix.
 |      
 |      Parameters
 |      ----------
 |      source : str or file-like
 |          Matrix Market filename (extensions .mtx, .mtz.gz)
 |          or open file object.
 |      
 |      Returns
 |      -------
 |      a : ndarray or coo_matrix
 |          Dense or sparse matrix depending on the matrix format in the
 |          Matrix Market file.
 |  
 |  write(self, target, a, comment='', field=None, precision=None, symmetry=None)
 |      Writes sparse or dense array `a` to Matrix Market file-like `target`.
 |      
 |      Parameters
 |      ----------
 |      target : str or file-like
 |          Matrix Market filename (extension .mtx) or open file-like object.
 |      a : array like
 |          Sparse or dense 2D array.
 |      comment : str, optional
 |          Comments to be prepended to the Matrix Market file.
 |      field : None or str, optional
 |          Either 'real', 'complex', 'pattern', or 'integer'.
 |      precision : None or int, optional
 |          Number of digits to display for real or complex values.
 |      symmetry : None or str, optional
 |          Either 'general', 'symmetric', 'skew-symmetric', or 'hermitian'.
 |          If symmetry is None the symmetry type of 'a' is determined by its
 |          values.
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  info(source) from builtins.type
 |      Return size, storage parameters from Matrix Market file-like 'source'.
 |      
 |      Parameters
 |      ----------
 |      source : str or file-like
 |          Matrix Market filename (extension .mtx) or open file-like object
 |      
 |      Returns
 |      -------
 |      rows : int
 |          Number of matrix rows.
 |      cols : int
 |          Number of matrix columns.
 |      entries : int
 |          Number of non-zero entries of a sparse matrix
 |          or rows*cols for a dense matrix.
 |      format : str
 |          Either 'coordinate' or 'array'.
 |      field : str
 |          Either 'real', 'complex', 'pattern', or 'integer'.
 |      symmetry : str
 |          Either 'general', 'symmetric', 'skew-symmetric', or 'hermitian'.
 |  
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |  
 |  reader()
 |      # -------------------------------------------------------------------------
 |  
 |  writer()
 |      # -------------------------------------------------------------------------
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  cols
 |  
 |  entries
 |  
 |  field
 |  
 |  format
 |  
 |  has_symmetry
 |  
 |  rows
 |  
 |  symmetry
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  DTYPES_BY_FIELD = {'complex': 'D', 'integer': 'intp', 'pattern': 'd', ...
 |  
 |  FIELD_COMPLEX = 'complex'
 |  
 |  FIELD_INTEGER = 'integer'
 |  
 |  FIELD_PATTERN = 'pattern'
 |  
 |  FIELD_REAL = 'real'
 |  
 |  FIELD_UNSIGNED = 'unsigned-integer'
 |  
 |  FIELD_VALUES = ('integer', 'unsigned-integer', 'real', 'complex', 'pat...
 |  
 |  FORMAT_ARRAY = 'array'
 |  
 |  FORMAT_COORDINATE = 'coordinate'
 |  
 |  FORMAT_VALUES = ('coordinate', 'array')
 |  
 |  SYMMETRY_GENERAL = 'general'
 |  
 |  SYMMETRY_HERMITIAN = 'hermitian'
 |  
 |  SYMMETRY_SKEW_SYMMETRIC = 'skew-symmetric'
 |  
 |  SYMMETRY_SYMMETRIC = 'symmetric'
 |  
 |  SYMMETRY_VALUES = ('general', 'symmetric', 'skew-symmetric', 'hermitia...
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, **kwargs)',)"
scipy,1.1.0,scipy.io.mmio.MMFile._validate_field,io.mmio.MMFile,_validate_field,"Python Library Documentation: method _validate_field in module scipy.io.mmio

_validate_field(field) method of builtins.type instance
",method,"('(field)',)",scipy,1.1.0,scipy.io.mmio.MMFile._validate_field,io.mmio.MMFile,_validate_field,"Python Library Documentation: method _validate_field in module scipy.io.mmio

_validate_field(field) method of builtins.type instance
",method,"('self', 'field')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(field)',)"
scipy,1.1.0,scipy.io.mmio.MMFile._validate_format,io.mmio.MMFile,_validate_format,"Python Library Documentation: method _validate_format in module scipy.io.mmio

_validate_format(format) method of builtins.type instance
",method,"('(format)',)",scipy,1.1.0,scipy.io.mmio.MMFile._validate_format,io.mmio.MMFile,_validate_format,"Python Library Documentation: method _validate_format in module scipy.io.mmio

_validate_format(format) method of builtins.type instance
",method,"('self', 'format')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(format)',)"
scipy,1.1.0,scipy.io.mmio.MMFile._validate_symmetry,io.mmio.MMFile,_validate_symmetry,"Python Library Documentation: method _validate_symmetry in module scipy.io.mmio

_validate_symmetry(symmetry) method of builtins.type instance
",method,"('(symmetry)',)",scipy,1.1.0,scipy.io.mmio.MMFile._validate_symmetry,io.mmio.MMFile,_validate_symmetry,"Python Library Documentation: method _validate_symmetry in module scipy.io.mmio

_validate_symmetry(symmetry) method of builtins.type instance
",method,"('self', 'symmetry')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(symmetry)',)"
scipy,1.1.0,scipy.io.mmio.MMFile.info,io.mmio.MMFile,info,"Python Library Documentation: method info in module scipy.io.mmio

info(source) method of builtins.type instance
    Return size, storage parameters from Matrix Market file-like 'source'.
    
    Parameters
    ----------
    source : str or file-like
        Matrix Market filename (extension .mtx) or open file-like object
    
    Returns
    -------
    rows : int
        Number of matrix rows.
    cols : int
        Number of matrix columns.
    entries : int
        Number of non-zero entries of a sparse matrix
        or rows*cols for a dense matrix.
    format : str
        Either 'coordinate' or 'array'.
    field : str
        Either 'real', 'complex', 'pattern', or 'integer'.
    symmetry : str
        Either 'general', 'symmetric', 'skew-symmetric', or 'hermitian'.
",method,"('(source)',)",scipy,1.1.0,scipy.io.mmio.MMFile.info,io.mmio.MMFile,info,"Python Library Documentation: method info in module scipy.io.mmio

info(source) method of builtins.type instance
    Return size, storage parameters from Matrix Market file-like 'source'.
    
    Parameters
    ----------
    source : str or file-like
        Matrix Market filename (extension .mtx) or open file-like object
    
    Returns
    -------
    rows : int
        Number of matrix rows.
    cols : int
        Number of matrix columns.
    entries : int
        Number of non-zero entries of a sparse matrix
        or rows*cols for a dense matrix.
    format : str
        Either 'coordinate' or 'array'.
    field : str
        Either 'real', 'complex', 'pattern', or 'integer'.
    symmetry : str
        Either 'general', 'symmetric', 'skew-symmetric', or 'hermitian'.
",method,"('self', 'source')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(source)',)"
scipy,1.1.0,scipy.io.mmio._is_fromfile_compatible,io.mmio,_is_fromfile_compatible,"Python Library Documentation: function _is_fromfile_compatible in module scipy.io.mmio

_is_fromfile_compatible(stream)
    Check whether `stream` is compatible with numpy.fromfile.
    
    Passing a gzipped file object to ``fromfile/fromstring`` doesn't work with
    Python3.
",function,"('(stream)',)",scipy,1.1.0,scipy.io.mmio._is_fromfile_compatible,io.mmio,_is_fromfile_compatible,"Python Library Documentation: function _is_fromfile_compatible in module scipy.io.mmio

_is_fromfile_compatible(stream)
    Check whether `stream` is compatible with numpy.fromfile.
    
    Passing a gzipped file object to ``fromfile/fromstring`` doesn't work with
    Python3.
",function,"('stream',)","(nan,)","(nan,)","('arg_info',)","('(stream)',)"
scipy,1.1.0,scipy.io.mmio.asarray,io.mmio,asarray,"Python Library Documentation: function asarray in module numpy.core.numeric

asarray(a, dtype=None, order=None)
    Convert the input to an array.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
        Whether to use row-major (C-style) or
        column-major (Fortran-style) memory representation.
        Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray with matching dtype and order.  If `a` is a
        subclass of ndarray, a base class ndarray is returned.
    
    See Also
    --------
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    asarray_chkfinite : Similar function which checks input for NaNs and Infs.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array:
    
    >>> a = [1, 2]
    >>> np.asarray(a)
    array([1, 2])
    
    Existing arrays are not copied:
    
    >>> a = np.array([1, 2])
    >>> np.asarray(a) is a
    True
    
    If `dtype` is set, array is copied only if dtype does not match:
    
    >>> a = np.array([1, 2], dtype=np.float32)
    >>> np.asarray(a, dtype=np.float32) is a
    True
    >>> np.asarray(a, dtype=np.float64) is a
    False
    
    Contrary to `asanyarray`, ndarray subclasses are not passed through:
    
    >>> issubclass(np.matrix, np.ndarray)
    True
    >>> a = np.matrix([[1, 2]])
    >>> np.asarray(a) is a
    False
    >>> np.asanyarray(a) is a
    True
",function,"('(a, dtype=None, order=None)',)",scipy,1.1.0,scipy.io.mmio.asarray,io.mmio,asarray,"Python Library Documentation: function asarray in module numpy.core.numeric

asarray(a, dtype=None, order=None)
    Convert the input to an array.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
        Whether to use row-major (C-style) or
        column-major (Fortran-style) memory representation.
        Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray with matching dtype and order.  If `a` is a
        subclass of ndarray, a base class ndarray is returned.
    
    See Also
    --------
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    asarray_chkfinite : Similar function which checks input for NaNs and Infs.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array:
    
    >>> a = [1, 2]
    >>> np.asarray(a)
    array([1, 2])
    
    Existing arrays are not copied:
    
    >>> a = np.array([1, 2])
    >>> np.asarray(a) is a
    True
    
    If `dtype` is set, array is copied only if dtype does not match:
    
    >>> a = np.array([1, 2], dtype=np.float32)
    >>> np.asarray(a, dtype=np.float32) is a
    True
    >>> np.asarray(a, dtype=np.float64) is a
    False
    
    Contrary to `asanyarray`, ndarray subclasses are not passed through:
    
    >>> issubclass(np.matrix, np.ndarray)
    True
    >>> a = np.matrix([[1, 2]])
    >>> np.asarray(a) is a
    False
    >>> np.asanyarray(a) is a
    True
",function,"('a', 'dtype', 'order')","(nan, None, None)","(nan, 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(a, dtype=None, order=None)',)"
scipy,1.1.0,scipy.io.mmio.asbytes,io.mmio,asbytes,"Python Library Documentation: function asbytes in module numpy.compat.py3k

asbytes(s)
",function,"('(s)',)",scipy,1.1.0,scipy.io.mmio.asbytes,io.mmio,asbytes,"Python Library Documentation: function asbytes in module numpy.compat.py3k

asbytes(s)
",function,"('s',)","(nan,)","(nan,)","('arg_info',)","('(s)',)"
scipy,1.1.0,scipy.io.mmio.ascontiguousarray,io.mmio,ascontiguousarray,"Python Library Documentation: function ascontiguousarray in module numpy.core.numeric

ascontiguousarray(a, dtype=None)
    Return a contiguous array in memory (C order).
    
    Parameters
    ----------
    a : array_like
        Input array.
    dtype : str or dtype object, optional
        Data-type of returned array.
    
    Returns
    -------
    out : ndarray
        Contiguous array of same shape and content as `a`, with type `dtype`
        if specified.
    
    See Also
    --------
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    require : Return an ndarray that satisfies requirements.
    ndarray.flags : Information about the memory layout of the array.
    
    Examples
    --------
    >>> x = np.arange(6).reshape(2,3)
    >>> np.ascontiguousarray(x, dtype=np.float32)
    array([[ 0.,  1.,  2.],
           [ 3.,  4.,  5.]], dtype=float32)
    >>> x.flags['C_CONTIGUOUS']
    True
",function,"('(a, dtype=None)',)",scipy,1.1.0,scipy.io.mmio.ascontiguousarray,io.mmio,ascontiguousarray,"Python Library Documentation: function ascontiguousarray in module numpy.core.numeric

ascontiguousarray(a, dtype=None)
    Return a contiguous array in memory (C order).
    
    Parameters
    ----------
    a : array_like
        Input array.
    dtype : str or dtype object, optional
        Data-type of returned array.
    
    Returns
    -------
    out : ndarray
        Contiguous array of same shape and content as `a`, with type `dtype`
        if specified.
    
    See Also
    --------
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    require : Return an ndarray that satisfies requirements.
    ndarray.flags : Information about the memory layout of the array.
    
    Examples
    --------
    >>> x = np.arange(6).reshape(2,3)
    >>> np.ascontiguousarray(x, dtype=np.float32)
    array([[ 0.,  1.,  2.],
           [ 3.,  4.,  5.]], dtype=float32)
    >>> x.flags['C_CONTIGUOUS']
    True
",function,"('a', 'dtype')","(nan, None)","(nan, 'NoneType')","('arg_info', 'arg_info')","('(a, dtype=None)',)"
scipy,1.1.0,scipy.io.mmio.asstr,io.mmio,asstr,"Python Library Documentation: function asstr in module numpy.compat.py3k

asstr(s)
",function,"('(s)',)",scipy,1.1.0,scipy.io.mmio.asstr,io.mmio,asstr,"Python Library Documentation: function asstr in module numpy.compat.py3k

asstr(s)
",function,"('s',)","(nan,)","(nan,)","('arg_info',)","('(s)',)"
scipy,1.1.0,scipy.io.mmio.coo_matrix,io.mmio,coo_matrix,"Python Library Documentation: class coo_matrix in module scipy.sparse.coo

class coo_matrix(scipy.sparse.data._data_matrix, scipy.sparse.data._minmax_mixin)
 |  A sparse matrix in COOrdinate format.
 |  
 |  Also known as the 'ijv' or 'triplet' format.
 |  
 |  This can be instantiated in several ways:
 |      coo_matrix(D)
 |          with a dense matrix D
 |  
 |      coo_matrix(S)
 |          with another sparse matrix S (equivalent to S.tocoo())
 |  
 |      coo_matrix((M, N), [dtype])
 |          to construct an empty matrix with shape (M, N)
 |          dtype is optional, defaulting to dtype='d'.
 |  
 |      coo_matrix((data, (i, j)), [shape=(M, N)])
 |          to construct from three arrays:
 |              1. data[:]   the entries of the matrix, in any order
 |              2. i[:]      the row indices of the matrix entries
 |              3. j[:]      the column indices of the matrix entries
 |  
 |          Where ``A[i[k], j[k]] = data[k]``.  When shape is not
 |          specified, it is inferred from the index arrays
 |  
 |  Attributes
 |  ----------
 |  dtype : dtype
 |      Data type of the matrix
 |  shape : 2-tuple
 |      Shape of the matrix
 |  ndim : int
 |      Number of dimensions (this is always 2)
 |  nnz
 |      Number of nonzero elements
 |  data
 |      COO format data array of the matrix
 |  row
 |      COO format row index array of the matrix
 |  col
 |      COO format column index array of the matrix
 |  
 |  Notes
 |  -----
 |  
 |  Sparse matrices can be used in arithmetic operations: they support
 |  addition, subtraction, multiplication, division, and matrix power.
 |  
 |  Advantages of the COO format
 |      - facilitates fast conversion among sparse formats
 |      - permits duplicate entries (see example)
 |      - very fast conversion to and from CSR/CSC formats
 |  
 |  Disadvantages of the COO format
 |      - does not directly support:
 |          + arithmetic operations
 |          + slicing
 |  
 |  Intended Usage
 |      - COO is a fast format for constructing sparse matrices
 |      - Once a matrix has been constructed, convert to CSR or
 |        CSC format for fast arithmetic and matrix vector operations
 |      - By default when converting to CSR or CSC format, duplicate (i,j)
 |        entries will be summed together.  This facilitates efficient
 |        construction of finite element matrices and the like. (see example)
 |  
 |  Examples
 |  --------
 |  
 |  >>> # Constructing an empty matrix
 |  >>> from scipy.sparse import coo_matrix
 |  >>> coo_matrix((3, 4), dtype=np.int8).toarray()
 |  array([[0, 0, 0, 0],
 |         [0, 0, 0, 0],
 |         [0, 0, 0, 0]], dtype=int8)
 |  
 |  >>> # Constructing a matrix using ijv format
 |  >>> row  = np.array([0, 3, 1, 0])
 |  >>> col  = np.array([0, 3, 1, 2])
 |  >>> data = np.array([4, 5, 7, 9])
 |  >>> coo_matrix((data, (row, col)), shape=(4, 4)).toarray()
 |  array([[4, 0, 9, 0],
 |         [0, 7, 0, 0],
 |         [0, 0, 0, 0],
 |         [0, 0, 0, 5]])
 |  
 |  >>> # Constructing a matrix with duplicate indices
 |  >>> row  = np.array([0, 0, 1, 3, 1, 0, 0])
 |  >>> col  = np.array([0, 2, 1, 3, 1, 0, 0])
 |  >>> data = np.array([1, 1, 1, 1, 1, 1, 1])
 |  >>> coo = coo_matrix((data, (row, col)), shape=(4, 4))
 |  >>> # Duplicate indices are maintained until implicitly or explicitly summed
 |  >>> np.max(coo.data)
 |  1
 |  >>> coo.toarray()
 |  array([[3, 0, 1, 0],
 |         [0, 2, 0, 0],
 |         [0, 0, 0, 0],
 |         [0, 0, 0, 1]])
 |  
 |  Method resolution order:
 |      coo_matrix
 |      scipy.sparse.data._data_matrix
 |      scipy.sparse.base.spmatrix
 |      scipy.sparse.data._minmax_mixin
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, arg1, shape=None, dtype=None, copy=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  diagonal(self, k=0)
 |      Returns the k-th diagonal of the matrix.
 |      
 |      Parameters
 |      ----------
 |      k : int, optional
 |          Which diagonal to set, corresponding to elements a[i, i+k].
 |          Default: 0 (the main diagonal).
 |      
 |          .. versionadded:: 1.0
 |      
 |      See also
 |      --------
 |      numpy.diagonal : Equivalent numpy function.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> A.diagonal()
 |      array([1, 0, 5])
 |      >>> A.diagonal(k=1)
 |      array([2, 3])
 |  
 |  eliminate_zeros(self)
 |      Remove zero entries from the matrix
 |      
 |      This is an *in place* operation
 |  
 |  getnnz(self, axis=None)
 |      Number of stored values, including explicit zeros.
 |      
 |      Parameters
 |      ----------
 |      axis : None, 0, or 1
 |          Select between the number of values across the whole matrix, in
 |          each column, or in each row.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  reshape(self, *args, **kwargs)
 |      reshape(self, shape, order='C', copy=False)
 |      
 |      Gives a new shape to a sparse matrix without changing its data.
 |      
 |      Parameters
 |      ----------
 |      shape : length-2 tuple of ints
 |          The new shape should be compatible with the original shape.
 |      order : {'C', 'F'}, optional
 |          Read the elements using this index order. 'C' means to read and
 |          write the elements using C-like index order; e.g. read entire first
 |          row, then second row, etc. 'F' means to read and write the elements
 |          using Fortran-like index order; e.g. read entire first column, then
 |          second column, etc.
 |      copy : bool, optional
 |          Indicates whether or not attributes of self should be copied
 |          whenever possible. The degree to which attributes are copied varies
 |          depending on the type of sparse matrix being used.
 |      
 |      Returns
 |      -------
 |      reshaped_matrix : sparse matrix
 |          A sparse matrix with the given `shape`, not necessarily of the same
 |          format as the current object.
 |      
 |      See Also
 |      --------
 |      np.matrix.reshape : NumPy's implementation of 'reshape' for matrices
 |  
 |  resize(self, *shape)
 |      Resize the matrix in-place to dimensions given by ``shape``
 |      
 |      Any elements that lie within the new shape will remain at the same
 |      indices, while non-zero elements lying outside the new shape are
 |      removed.
 |      
 |      Parameters
 |      ----------
 |      shape : (int, int)
 |          number of rows and columns in the new matrix
 |      
 |      Notes
 |      -----
 |      The semantics are not identical to `numpy.ndarray.resize` or
 |      `numpy.resize`.  Here, the same data will be maintained at each index
 |      before and after reshape, if that index is within the new bounds.  In
 |      numpy, resizing maintains contiguity of the array, moving elements
 |      around in the logical matrix but not within a flattened representation.
 |      
 |      We give no guarantees about whether the underlying data attributes
 |      (arrays, etc.) will be modified in place or replaced with new objects.
 |  
 |  sum_duplicates(self)
 |      Eliminate duplicate matrix entries by adding them together
 |      
 |      This is an *in place* operation
 |  
 |  toarray(self, order=None, out=None)
 |      See the docstring for `spmatrix.toarray`.
 |  
 |  tocoo(self, copy=False)
 |      Convert this matrix to COOrdinate format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant coo_matrix.
 |  
 |  tocsc(self, copy=False)
 |      Convert this matrix to Compressed Sparse Column format
 |      
 |      Duplicate entries will be summed together.
 |      
 |      Examples
 |      --------
 |      >>> from numpy import array
 |      >>> from scipy.sparse import coo_matrix
 |      >>> row  = array([0, 0, 1, 3, 1, 0, 0])
 |      >>> col  = array([0, 2, 1, 3, 1, 0, 0])
 |      >>> data = array([1, 1, 1, 1, 1, 1, 1])
 |      >>> A = coo_matrix((data, (row, col)), shape=(4, 4)).tocsc()
 |      >>> A.toarray()
 |      array([[3, 0, 1, 0],
 |             [0, 2, 0, 0],
 |             [0, 0, 0, 0],
 |             [0, 0, 0, 1]])
 |  
 |  tocsr(self, copy=False)
 |      Convert this matrix to Compressed Sparse Row format
 |      
 |      Duplicate entries will be summed together.
 |      
 |      Examples
 |      --------
 |      >>> from numpy import array
 |      >>> from scipy.sparse import coo_matrix
 |      >>> row  = array([0, 0, 1, 3, 1, 0, 0])
 |      >>> col  = array([0, 2, 1, 3, 1, 0, 0])
 |      >>> data = array([1, 1, 1, 1, 1, 1, 1])
 |      >>> A = coo_matrix((data, (row, col)), shape=(4, 4)).tocsr()
 |      >>> A.toarray()
 |      array([[3, 0, 1, 0],
 |             [0, 2, 0, 0],
 |             [0, 0, 0, 0],
 |             [0, 0, 0, 1]])
 |  
 |  todia(self, copy=False)
 |      Convert this matrix to sparse DIAgonal format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dia_matrix.
 |  
 |  todok(self, copy=False)
 |      Convert this matrix to Dictionary Of Keys format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dok_matrix.
 |  
 |  transpose(self, axes=None, copy=False)
 |      Reverses the dimensions of the sparse matrix.
 |      
 |      Parameters
 |      ----------
 |      axes : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value.
 |      copy : bool, optional
 |          Indicates whether or not attributes of `self` should be
 |          copied whenever possible. The degree to which attributes
 |          are copied varies depending on the type of sparse matrix
 |          being used.
 |      
 |      Returns
 |      -------
 |      p : `self` with the dimensions reversed.
 |      
 |      See Also
 |      --------
 |      np.matrix.transpose : NumPy's implementation of 'transpose'
 |                            for matrices
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  format = 'coo'
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._data_matrix:
 |  
 |  __abs__(self)
 |  
 |  __imul__(self, other)
 |  
 |  __itruediv__(self, other)
 |  
 |  __neg__(self)
 |  
 |  arcsin(self)
 |      Element-wise arcsin.
 |      
 |      See numpy.arcsin for more information.
 |  
 |  arcsinh(self)
 |      Element-wise arcsinh.
 |      
 |      See numpy.arcsinh for more information.
 |  
 |  arctan(self)
 |      Element-wise arctan.
 |      
 |      See numpy.arctan for more information.
 |  
 |  arctanh(self)
 |      Element-wise arctanh.
 |      
 |      See numpy.arctanh for more information.
 |  
 |  astype(self, dtype, casting='unsafe', copy=True)
 |      Cast the matrix elements to a specified type.
 |      
 |      Parameters
 |      ----------
 |      dtype : string or numpy dtype
 |          Typecode or data-type to which to cast the data.
 |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
 |          Controls what kind of data casting may occur.
 |          Defaults to 'unsafe' for backwards compatibility.
 |          'no' means the data types should not be cast at all.
 |          'equiv' means only byte-order changes are allowed.
 |          'safe' means only casts which can preserve values are allowed.
 |          'same_kind' means only safe casts or casts within a kind,
 |          like float64 to float32, are allowed.
 |          'unsafe' means any data conversions may be done.
 |      copy : bool, optional
 |          If `copy` is `False`, the result might share some memory with this
 |          matrix. If `copy` is `True`, it is guaranteed that the result and
 |          this matrix do not share any memory.
 |  
 |  ceil(self)
 |      Element-wise ceil.
 |      
 |      See numpy.ceil for more information.
 |  
 |  conj(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  copy(self)
 |      Returns a copy of this matrix.
 |      
 |      No data/indices will be shared between the returned value and current
 |      matrix.
 |  
 |  count_nonzero(self)
 |      Number of non-zero entries, equivalent to
 |      
 |      np.count_nonzero(a.toarray())
 |      
 |      Unlike getnnz() and the nnz property, which return the number of stored
 |      entries (the length of the data attribute), this method counts the
 |      actual number of non-zero entries in data.
 |  
 |  deg2rad(self)
 |      Element-wise deg2rad.
 |      
 |      See numpy.deg2rad for more information.
 |  
 |  expm1(self)
 |      Element-wise expm1.
 |      
 |      See numpy.expm1 for more information.
 |  
 |  floor(self)
 |      Element-wise floor.
 |      
 |      See numpy.floor for more information.
 |  
 |  log1p(self)
 |      Element-wise log1p.
 |      
 |      See numpy.log1p for more information.
 |  
 |  power(self, n, dtype=None)
 |      This function performs element-wise power.
 |      
 |      Parameters
 |      ----------
 |      n : n is a scalar
 |      
 |      dtype : If dtype is not specified, the current dtype will be preserved.
 |  
 |  rad2deg(self)
 |      Element-wise rad2deg.
 |      
 |      See numpy.rad2deg for more information.
 |  
 |  rint(self)
 |      Element-wise rint.
 |      
 |      See numpy.rint for more information.
 |  
 |  sign(self)
 |      Element-wise sign.
 |      
 |      See numpy.sign for more information.
 |  
 |  sin(self)
 |      Element-wise sin.
 |      
 |      See numpy.sin for more information.
 |  
 |  sinh(self)
 |      Element-wise sinh.
 |      
 |      See numpy.sinh for more information.
 |  
 |  sqrt(self)
 |      Element-wise sqrt.
 |      
 |      See numpy.sqrt for more information.
 |  
 |  tan(self)
 |      Element-wise tan.
 |      
 |      See numpy.tan for more information.
 |  
 |  tanh(self)
 |      Element-wise tanh.
 |      
 |      See numpy.tanh for more information.
 |  
 |  trunc(self)
 |      Element-wise trunc.
 |      
 |      See numpy.trunc for more information.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.data._data_matrix:
 |  
 |  dtype
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.base.spmatrix:
 |  
 |  __add__(self, other)
 |  
 |  __bool__(self)
 |  
 |  __div__(self, other)
 |  
 |  __eq__(self, other)
 |      Return self==value.
 |  
 |  __ge__(self, other)
 |      Return self>=value.
 |  
 |  __getattr__(self, attr)
 |  
 |  __gt__(self, other)
 |      Return self>value.
 |  
 |  __iadd__(self, other)
 |  
 |  __idiv__(self, other)
 |  
 |  __isub__(self, other)
 |  
 |  __iter__(self)
 |  
 |  __le__(self, other)
 |      Return self<=value.
 |  
 |  __len__(self)
 |      # What should len(sparse) return? For consistency with dense matrices,
 |      # perhaps it should be the number of rows?  But for some uses the number of
 |      # non-zeros is more important.  For now, raise an exception!
 |  
 |  __lt__(self, other)
 |      Return self<value.
 |  
 |  __matmul__(self, other)
 |  
 |  __mul__(self, other)
 |      interpret other and call one of the following
 |      
 |      self._mul_scalar()
 |      self._mul_vector()
 |      self._mul_multivector()
 |      self._mul_sparse_matrix()
 |  
 |  __ne__(self, other)
 |      Return self!=value.
 |  
 |  __nonzero__ = __bool__(self)
 |  
 |  __pow__(self, other)
 |  
 |  __radd__(self, other)
 |  
 |  __rdiv__(self, other)
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __rmatmul__(self, other)
 |  
 |  __rmul__(self, other)
 |  
 |  __rsub__(self, other)
 |  
 |  __rtruediv__(self, other)
 |  
 |  __str__(self)
 |      Return str(self).
 |  
 |  __sub__(self, other)
 |  
 |  __truediv__(self, other)
 |  
 |  asformat(self, format, copy=False)
 |      Return this matrix in the passed sparse format.
 |      
 |      Parameters
 |      ----------
 |      format : {str, None}
 |          The desired sparse matrix format (""csr"", ""csc"", ""lil"", ""dok"", ...)
 |          or None for no conversion.
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : This matrix in the passed sparse format.
 |  
 |  asfptype(self)
 |      Upcast matrix to a floating point format (if necessary)
 |  
 |  conjugate(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  dot(self, other)
 |      Ordinary dot product
 |      
 |      Examples
 |      --------
 |      >>> import numpy as np
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> v = np.array([1, 0, -1])
 |      >>> A.dot(v)
 |      array([ 1, -3, -1], dtype=int64)
 |  
 |  getH(self)
 |      Return the Hermitian transpose of this matrix.
 |      
 |      See Also
 |      --------
 |      np.matrix.getH : NumPy's implementation of `getH` for matrices
 |  
 |  get_shape(self)
 |      Get shape of a matrix.
 |  
 |  getcol(self, j)
 |      Returns a copy of column j of the matrix, as an (m x 1) sparse
 |      matrix (column vector).
 |  
 |  getformat(self)
 |      Format of a matrix representation as a string.
 |  
 |  getmaxprint(self)
 |      Maximum number of elements to display when printed.
 |  
 |  getrow(self, i)
 |      Returns a copy of row i of the matrix, as a (1 x n) sparse
 |      matrix (row vector).
 |  
 |  maximum(self, other)
 |      Element-wise maximum between this and another matrix.
 |  
 |  mean(self, axis=None, dtype=None, out=None)
 |      Compute the arithmetic mean along the specified axis.
 |      
 |      Returns the average of the matrix elements. The average is taken
 |      over all elements in the matrix by default, otherwise over the
 |      specified axis. `float64` intermediate and return values are used
 |      for integer inputs.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the mean is computed. The default is to compute
 |          the mean of all elements in the matrix (i.e. `axis` = `None`).
 |      dtype : data-type, optional
 |          Type to use in computing the mean. For integer inputs, the default
 |          is `float64`; for floating point inputs, it is the same as the
 |          input dtype.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      m : np.matrix
 |      
 |      See Also
 |      --------
 |      np.matrix.mean : NumPy's implementation of 'mean' for matrices
 |  
 |  minimum(self, other)
 |      Element-wise minimum between this and another matrix.
 |  
 |  multiply(self, other)
 |      Point-wise multiplication by another matrix
 |  
 |  nonzero(self)
 |      nonzero indices
 |      
 |      Returns a tuple of arrays (row,col) containing the indices
 |      of the non-zero elements of the matrix.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1,2,0],[0,0,3],[4,0,5]])
 |      >>> A.nonzero()
 |      (array([0, 0, 1, 2, 2]), array([0, 1, 2, 0, 2]))
 |  
 |  set_shape(self, shape)
 |      See `reshape`.
 |  
 |  setdiag(self, values, k=0)
 |      Set diagonal or off-diagonal elements of the array.
 |      
 |      Parameters
 |      ----------
 |      values : array_like
 |          New values of the diagonal elements.
 |      
 |          Values may have any length.  If the diagonal is longer than values,
 |          then the remaining diagonal entries will not be set.  If values if
 |          longer than the diagonal, then the remaining values are ignored.
 |      
 |          If a scalar value is given, all of the diagonal is set to it.
 |      
 |      k : int, optional
 |          Which off-diagonal to set, corresponding to elements a[i,i+k].
 |          Default: 0 (the main diagonal).
 |  
 |  sum(self, axis=None, dtype=None, out=None)
 |      Sum the matrix elements over a given axis.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the sum of all the matrix elements, returning a scalar
 |          (i.e. `axis` = `None`).
 |      dtype : dtype, optional
 |          The type of the returned matrix and of the accumulator in which
 |          the elements are summed.  The dtype of `a` is used by default
 |          unless `a` has an integer dtype of less precision than the default
 |          platform integer.  In that case, if `a` is signed then the platform
 |          integer is used while if `a` is unsigned then an unsigned integer
 |          of the same precision as the platform integer is used.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      sum_along_axis : np.matrix
 |          A matrix with the same shape as `self`, with the specified
 |          axis removed.
 |      
 |      See Also
 |      --------
 |      np.matrix.sum : NumPy's implementation of 'sum' for matrices
 |  
 |  tobsr(self, blocksize=None, copy=False)
 |      Convert this matrix to Block Sparse Row format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant bsr_matrix.
 |      
 |      When blocksize=(R, C) is provided, it will be used for construction of
 |      the bsr_matrix.
 |  
 |  todense(self, order=None, out=None)
 |      Return a dense matrix representation of this matrix.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F'}, optional
 |          Whether to store multi-dimensional data in C (row-major)
 |          or Fortran (column-major) order in memory. The default
 |          is 'None', indicating the NumPy default of C-ordered.
 |          Cannot be specified in conjunction with the `out`
 |          argument.
 |      
 |      out : ndarray, 2-dimensional, optional
 |          If specified, uses this array (or `numpy.matrix`) as the
 |          output buffer instead of allocating a new array to
 |          return. The provided array must have the same shape and
 |          dtype as the sparse matrix on which you are calling the
 |          method.
 |      
 |      Returns
 |      -------
 |      arr : numpy.matrix, 2-dimensional
 |          A NumPy matrix object with the same shape and containing
 |          the same data represented by the sparse matrix, with the
 |          requested memory order. If `out` was passed and was an
 |          array (rather than a `numpy.matrix`), it will be filled
 |          with the appropriate values and returned wrapped in a
 |          `numpy.matrix` object that shares the same memory.
 |  
 |  tolil(self, copy=False)
 |      Convert this matrix to LInked List format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant lil_matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.base.spmatrix:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  nnz
 |      Number of stored values, including explicit zeros.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  shape
 |      Get shape of a matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.sparse.base.spmatrix:
 |  
 |  __array_priority__ = 10.1
 |  
 |  __hash__ = None
 |  
 |  ndim = 2
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._minmax_mixin:
 |  
 |  argmax(self, axis=None, out=None)
 |      Return indices of maximum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several maximum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmax is computed. If None (default), index
 |          of the maximum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      ind : np.matrix or int
 |          Indices of maximum elements. If matrix, its size along `axis` is 1.
 |  
 |  argmin(self, axis=None, out=None)
 |      Return indices of minimum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several minimum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmin is computed. If None (default), index
 |          of the minimum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |       ind : np.matrix or int
 |          Indices of minimum elements. If matrix, its size along `axis` is 1.
 |  
 |  max(self, axis=None, out=None)
 |      Return the maximum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the maximum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amax : coo_matrix or scalar
 |          Maximum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      min : The minimum value of a sparse matrix along a given axis.
 |      np.matrix.max : NumPy's implementation of 'max' for matrices
 |  
 |  min(self, axis=None, out=None)
 |      Return the minimum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the minimum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amin : coo_matrix or scalar
 |          Minimum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      max : The maximum value of a sparse matrix along a given axis.
 |      np.matrix.min : NumPy's implementation of 'min' for matrices
",class,"('(self, arg1, shape=None, dtype=None, copy=False)',)",scipy,1.1.0,scipy.io.mmio.coo_matrix,io.mmio,coo_matrix,"Python Library Documentation: class coo_matrix in module scipy.sparse.coo

class coo_matrix(scipy.sparse.data._data_matrix, scipy.sparse.data._minmax_mixin)
 |  A sparse matrix in COOrdinate format.
 |  
 |  Also known as the 'ijv' or 'triplet' format.
 |  
 |  This can be instantiated in several ways:
 |      coo_matrix(D)
 |          with a dense matrix D
 |  
 |      coo_matrix(S)
 |          with another sparse matrix S (equivalent to S.tocoo())
 |  
 |      coo_matrix((M, N), [dtype])
 |          to construct an empty matrix with shape (M, N)
 |          dtype is optional, defaulting to dtype='d'.
 |  
 |      coo_matrix((data, (i, j)), [shape=(M, N)])
 |          to construct from three arrays:
 |              1. data[:]   the entries of the matrix, in any order
 |              2. i[:]      the row indices of the matrix entries
 |              3. j[:]      the column indices of the matrix entries
 |  
 |          Where ``A[i[k], j[k]] = data[k]``.  When shape is not
 |          specified, it is inferred from the index arrays
 |  
 |  Attributes
 |  ----------
 |  dtype : dtype
 |      Data type of the matrix
 |  shape : 2-tuple
 |      Shape of the matrix
 |  ndim : int
 |      Number of dimensions (this is always 2)
 |  nnz
 |      Number of nonzero elements
 |  data
 |      COO format data array of the matrix
 |  row
 |      COO format row index array of the matrix
 |  col
 |      COO format column index array of the matrix
 |  
 |  Notes
 |  -----
 |  
 |  Sparse matrices can be used in arithmetic operations: they support
 |  addition, subtraction, multiplication, division, and matrix power.
 |  
 |  Advantages of the COO format
 |      - facilitates fast conversion among sparse formats
 |      - permits duplicate entries (see example)
 |      - very fast conversion to and from CSR/CSC formats
 |  
 |  Disadvantages of the COO format
 |      - does not directly support:
 |          + arithmetic operations
 |          + slicing
 |  
 |  Intended Usage
 |      - COO is a fast format for constructing sparse matrices
 |      - Once a matrix has been constructed, convert to CSR or
 |        CSC format for fast arithmetic and matrix vector operations
 |      - By default when converting to CSR or CSC format, duplicate (i,j)
 |        entries will be summed together.  This facilitates efficient
 |        construction of finite element matrices and the like. (see example)
 |  
 |  Examples
 |  --------
 |  
 |  >>> # Constructing an empty matrix
 |  >>> from scipy.sparse import coo_matrix
 |  >>> coo_matrix((3, 4), dtype=np.int8).toarray()
 |  array([[0, 0, 0, 0],
 |         [0, 0, 0, 0],
 |         [0, 0, 0, 0]], dtype=int8)
 |  
 |  >>> # Constructing a matrix using ijv format
 |  >>> row  = np.array([0, 3, 1, 0])
 |  >>> col  = np.array([0, 3, 1, 2])
 |  >>> data = np.array([4, 5, 7, 9])
 |  >>> coo_matrix((data, (row, col)), shape=(4, 4)).toarray()
 |  array([[4, 0, 9, 0],
 |         [0, 7, 0, 0],
 |         [0, 0, 0, 0],
 |         [0, 0, 0, 5]])
 |  
 |  >>> # Constructing a matrix with duplicate indices
 |  >>> row  = np.array([0, 0, 1, 3, 1, 0, 0])
 |  >>> col  = np.array([0, 2, 1, 3, 1, 0, 0])
 |  >>> data = np.array([1, 1, 1, 1, 1, 1, 1])
 |  >>> coo = coo_matrix((data, (row, col)), shape=(4, 4))
 |  >>> # Duplicate indices are maintained until implicitly or explicitly summed
 |  >>> np.max(coo.data)
 |  1
 |  >>> coo.toarray()
 |  array([[3, 0, 1, 0],
 |         [0, 2, 0, 0],
 |         [0, 0, 0, 0],
 |         [0, 0, 0, 1]])
 |  
 |  Method resolution order:
 |      coo_matrix
 |      scipy.sparse.data._data_matrix
 |      scipy.sparse.base.spmatrix
 |      scipy.sparse.data._minmax_mixin
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __init__(self, arg1, shape=None, dtype=None, copy=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  diagonal(self, k=0)
 |      Returns the k-th diagonal of the matrix.
 |      
 |      Parameters
 |      ----------
 |      k : int, optional
 |          Which diagonal to set, corresponding to elements a[i, i+k].
 |          Default: 0 (the main diagonal).
 |      
 |          .. versionadded:: 1.0
 |      
 |      See also
 |      --------
 |      numpy.diagonal : Equivalent numpy function.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> A.diagonal()
 |      array([1, 0, 5])
 |      >>> A.diagonal(k=1)
 |      array([2, 3])
 |  
 |  eliminate_zeros(self)
 |      Remove zero entries from the matrix
 |      
 |      This is an *in place* operation
 |  
 |  getnnz(self, axis=None)
 |      Number of stored values, including explicit zeros.
 |      
 |      Parameters
 |      ----------
 |      axis : None, 0, or 1
 |          Select between the number of values across the whole matrix, in
 |          each column, or in each row.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  reshape(self, *args, **kwargs)
 |      reshape(self, shape, order='C', copy=False)
 |      
 |      Gives a new shape to a sparse matrix without changing its data.
 |      
 |      Parameters
 |      ----------
 |      shape : length-2 tuple of ints
 |          The new shape should be compatible with the original shape.
 |      order : {'C', 'F'}, optional
 |          Read the elements using this index order. 'C' means to read and
 |          write the elements using C-like index order; e.g. read entire first
 |          row, then second row, etc. 'F' means to read and write the elements
 |          using Fortran-like index order; e.g. read entire first column, then
 |          second column, etc.
 |      copy : bool, optional
 |          Indicates whether or not attributes of self should be copied
 |          whenever possible. The degree to which attributes are copied varies
 |          depending on the type of sparse matrix being used.
 |      
 |      Returns
 |      -------
 |      reshaped_matrix : sparse matrix
 |          A sparse matrix with the given `shape`, not necessarily of the same
 |          format as the current object.
 |      
 |      See Also
 |      --------
 |      np.matrix.reshape : NumPy's implementation of 'reshape' for matrices
 |  
 |  resize(self, *shape)
 |      Resize the matrix in-place to dimensions given by ``shape``
 |      
 |      Any elements that lie within the new shape will remain at the same
 |      indices, while non-zero elements lying outside the new shape are
 |      removed.
 |      
 |      Parameters
 |      ----------
 |      shape : (int, int)
 |          number of rows and columns in the new matrix
 |      
 |      Notes
 |      -----
 |      The semantics are not identical to `numpy.ndarray.resize` or
 |      `numpy.resize`.  Here, the same data will be maintained at each index
 |      before and after reshape, if that index is within the new bounds.  In
 |      numpy, resizing maintains contiguity of the array, moving elements
 |      around in the logical matrix but not within a flattened representation.
 |      
 |      We give no guarantees about whether the underlying data attributes
 |      (arrays, etc.) will be modified in place or replaced with new objects.
 |  
 |  sum_duplicates(self)
 |      Eliminate duplicate matrix entries by adding them together
 |      
 |      This is an *in place* operation
 |  
 |  toarray(self, order=None, out=None)
 |      See the docstring for `spmatrix.toarray`.
 |  
 |  tocoo(self, copy=False)
 |      Convert this matrix to COOrdinate format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant coo_matrix.
 |  
 |  tocsc(self, copy=False)
 |      Convert this matrix to Compressed Sparse Column format
 |      
 |      Duplicate entries will be summed together.
 |      
 |      Examples
 |      --------
 |      >>> from numpy import array
 |      >>> from scipy.sparse import coo_matrix
 |      >>> row  = array([0, 0, 1, 3, 1, 0, 0])
 |      >>> col  = array([0, 2, 1, 3, 1, 0, 0])
 |      >>> data = array([1, 1, 1, 1, 1, 1, 1])
 |      >>> A = coo_matrix((data, (row, col)), shape=(4, 4)).tocsc()
 |      >>> A.toarray()
 |      array([[3, 0, 1, 0],
 |             [0, 2, 0, 0],
 |             [0, 0, 0, 0],
 |             [0, 0, 0, 1]])
 |  
 |  tocsr(self, copy=False)
 |      Convert this matrix to Compressed Sparse Row format
 |      
 |      Duplicate entries will be summed together.
 |      
 |      Examples
 |      --------
 |      >>> from numpy import array
 |      >>> from scipy.sparse import coo_matrix
 |      >>> row  = array([0, 0, 1, 3, 1, 0, 0])
 |      >>> col  = array([0, 2, 1, 3, 1, 0, 0])
 |      >>> data = array([1, 1, 1, 1, 1, 1, 1])
 |      >>> A = coo_matrix((data, (row, col)), shape=(4, 4)).tocsr()
 |      >>> A.toarray()
 |      array([[3, 0, 1, 0],
 |             [0, 2, 0, 0],
 |             [0, 0, 0, 0],
 |             [0, 0, 0, 1]])
 |  
 |  todia(self, copy=False)
 |      Convert this matrix to sparse DIAgonal format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dia_matrix.
 |  
 |  todok(self, copy=False)
 |      Convert this matrix to Dictionary Of Keys format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant dok_matrix.
 |  
 |  transpose(self, axes=None, copy=False)
 |      Reverses the dimensions of the sparse matrix.
 |      
 |      Parameters
 |      ----------
 |      axes : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value.
 |      copy : bool, optional
 |          Indicates whether or not attributes of `self` should be
 |          copied whenever possible. The degree to which attributes
 |          are copied varies depending on the type of sparse matrix
 |          being used.
 |      
 |      Returns
 |      -------
 |      p : `self` with the dimensions reversed.
 |      
 |      See Also
 |      --------
 |      np.matrix.transpose : NumPy's implementation of 'transpose'
 |                            for matrices
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  format = 'coo'
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._data_matrix:
 |  
 |  __abs__(self)
 |  
 |  __imul__(self, other)
 |  
 |  __itruediv__(self, other)
 |  
 |  __neg__(self)
 |  
 |  arcsin(self)
 |      Element-wise arcsin.
 |      
 |      See numpy.arcsin for more information.
 |  
 |  arcsinh(self)
 |      Element-wise arcsinh.
 |      
 |      See numpy.arcsinh for more information.
 |  
 |  arctan(self)
 |      Element-wise arctan.
 |      
 |      See numpy.arctan for more information.
 |  
 |  arctanh(self)
 |      Element-wise arctanh.
 |      
 |      See numpy.arctanh for more information.
 |  
 |  astype(self, dtype, casting='unsafe', copy=True)
 |      Cast the matrix elements to a specified type.
 |      
 |      Parameters
 |      ----------
 |      dtype : string or numpy dtype
 |          Typecode or data-type to which to cast the data.
 |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
 |          Controls what kind of data casting may occur.
 |          Defaults to 'unsafe' for backwards compatibility.
 |          'no' means the data types should not be cast at all.
 |          'equiv' means only byte-order changes are allowed.
 |          'safe' means only casts which can preserve values are allowed.
 |          'same_kind' means only safe casts or casts within a kind,
 |          like float64 to float32, are allowed.
 |          'unsafe' means any data conversions may be done.
 |      copy : bool, optional
 |          If `copy` is `False`, the result might share some memory with this
 |          matrix. If `copy` is `True`, it is guaranteed that the result and
 |          this matrix do not share any memory.
 |  
 |  ceil(self)
 |      Element-wise ceil.
 |      
 |      See numpy.ceil for more information.
 |  
 |  conj(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  copy(self)
 |      Returns a copy of this matrix.
 |      
 |      No data/indices will be shared between the returned value and current
 |      matrix.
 |  
 |  count_nonzero(self)
 |      Number of non-zero entries, equivalent to
 |      
 |      np.count_nonzero(a.toarray())
 |      
 |      Unlike getnnz() and the nnz property, which return the number of stored
 |      entries (the length of the data attribute), this method counts the
 |      actual number of non-zero entries in data.
 |  
 |  deg2rad(self)
 |      Element-wise deg2rad.
 |      
 |      See numpy.deg2rad for more information.
 |  
 |  expm1(self)
 |      Element-wise expm1.
 |      
 |      See numpy.expm1 for more information.
 |  
 |  floor(self)
 |      Element-wise floor.
 |      
 |      See numpy.floor for more information.
 |  
 |  log1p(self)
 |      Element-wise log1p.
 |      
 |      See numpy.log1p for more information.
 |  
 |  power(self, n, dtype=None)
 |      This function performs element-wise power.
 |      
 |      Parameters
 |      ----------
 |      n : n is a scalar
 |      
 |      dtype : If dtype is not specified, the current dtype will be preserved.
 |  
 |  rad2deg(self)
 |      Element-wise rad2deg.
 |      
 |      See numpy.rad2deg for more information.
 |  
 |  rint(self)
 |      Element-wise rint.
 |      
 |      See numpy.rint for more information.
 |  
 |  sign(self)
 |      Element-wise sign.
 |      
 |      See numpy.sign for more information.
 |  
 |  sin(self)
 |      Element-wise sin.
 |      
 |      See numpy.sin for more information.
 |  
 |  sinh(self)
 |      Element-wise sinh.
 |      
 |      See numpy.sinh for more information.
 |  
 |  sqrt(self)
 |      Element-wise sqrt.
 |      
 |      See numpy.sqrt for more information.
 |  
 |  tan(self)
 |      Element-wise tan.
 |      
 |      See numpy.tan for more information.
 |  
 |  tanh(self)
 |      Element-wise tanh.
 |      
 |      See numpy.tanh for more information.
 |  
 |  trunc(self)
 |      Element-wise trunc.
 |      
 |      See numpy.trunc for more information.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.data._data_matrix:
 |  
 |  dtype
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.base.spmatrix:
 |  
 |  __add__(self, other)
 |  
 |  __bool__(self)
 |  
 |  __div__(self, other)
 |  
 |  __eq__(self, other)
 |      Return self==value.
 |  
 |  __ge__(self, other)
 |      Return self>=value.
 |  
 |  __getattr__(self, attr)
 |  
 |  __gt__(self, other)
 |      Return self>value.
 |  
 |  __iadd__(self, other)
 |  
 |  __idiv__(self, other)
 |  
 |  __isub__(self, other)
 |  
 |  __iter__(self)
 |  
 |  __le__(self, other)
 |      Return self<=value.
 |  
 |  __len__(self)
 |      # What should len(sparse) return? For consistency with dense matrices,
 |      # perhaps it should be the number of rows?  But for some uses the number of
 |      # non-zeros is more important.  For now, raise an exception!
 |  
 |  __lt__(self, other)
 |      Return self<value.
 |  
 |  __matmul__(self, other)
 |  
 |  __mul__(self, other)
 |      interpret other and call one of the following
 |      
 |      self._mul_scalar()
 |      self._mul_vector()
 |      self._mul_multivector()
 |      self._mul_sparse_matrix()
 |  
 |  __ne__(self, other)
 |      Return self!=value.
 |  
 |  __nonzero__ = __bool__(self)
 |  
 |  __pow__(self, other)
 |  
 |  __radd__(self, other)
 |  
 |  __rdiv__(self, other)
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __rmatmul__(self, other)
 |  
 |  __rmul__(self, other)
 |  
 |  __rsub__(self, other)
 |  
 |  __rtruediv__(self, other)
 |  
 |  __str__(self)
 |      Return str(self).
 |  
 |  __sub__(self, other)
 |  
 |  __truediv__(self, other)
 |  
 |  asformat(self, format, copy=False)
 |      Return this matrix in the passed sparse format.
 |      
 |      Parameters
 |      ----------
 |      format : {str, None}
 |          The desired sparse matrix format (""csr"", ""csc"", ""lil"", ""dok"", ...)
 |          or None for no conversion.
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : This matrix in the passed sparse format.
 |  
 |  asfptype(self)
 |      Upcast matrix to a floating point format (if necessary)
 |  
 |  conjugate(self, copy=True)
 |      Element-wise complex conjugation.
 |      
 |      If the matrix is of non-complex data type and `copy` is False,
 |      this method does nothing and the data is not copied.
 |      
 |      Parameters
 |      ----------
 |      copy : bool, optional
 |          If True, the result is guaranteed to not share data with self.
 |      
 |      Returns
 |      -------
 |      A : The element-wise complex conjugate.
 |  
 |  dot(self, other)
 |      Ordinary dot product
 |      
 |      Examples
 |      --------
 |      >>> import numpy as np
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
 |      >>> v = np.array([1, 0, -1])
 |      >>> A.dot(v)
 |      array([ 1, -3, -1], dtype=int64)
 |  
 |  getH(self)
 |      Return the Hermitian transpose of this matrix.
 |      
 |      See Also
 |      --------
 |      np.matrix.getH : NumPy's implementation of `getH` for matrices
 |  
 |  get_shape(self)
 |      Get shape of a matrix.
 |  
 |  getcol(self, j)
 |      Returns a copy of column j of the matrix, as an (m x 1) sparse
 |      matrix (column vector).
 |  
 |  getformat(self)
 |      Format of a matrix representation as a string.
 |  
 |  getmaxprint(self)
 |      Maximum number of elements to display when printed.
 |  
 |  getrow(self, i)
 |      Returns a copy of row i of the matrix, as a (1 x n) sparse
 |      matrix (row vector).
 |  
 |  maximum(self, other)
 |      Element-wise maximum between this and another matrix.
 |  
 |  mean(self, axis=None, dtype=None, out=None)
 |      Compute the arithmetic mean along the specified axis.
 |      
 |      Returns the average of the matrix elements. The average is taken
 |      over all elements in the matrix by default, otherwise over the
 |      specified axis. `float64` intermediate and return values are used
 |      for integer inputs.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the mean is computed. The default is to compute
 |          the mean of all elements in the matrix (i.e. `axis` = `None`).
 |      dtype : data-type, optional
 |          Type to use in computing the mean. For integer inputs, the default
 |          is `float64`; for floating point inputs, it is the same as the
 |          input dtype.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      m : np.matrix
 |      
 |      See Also
 |      --------
 |      np.matrix.mean : NumPy's implementation of 'mean' for matrices
 |  
 |  minimum(self, other)
 |      Element-wise minimum between this and another matrix.
 |  
 |  multiply(self, other)
 |      Point-wise multiplication by another matrix
 |  
 |  nonzero(self)
 |      nonzero indices
 |      
 |      Returns a tuple of arrays (row,col) containing the indices
 |      of the non-zero elements of the matrix.
 |      
 |      Examples
 |      --------
 |      >>> from scipy.sparse import csr_matrix
 |      >>> A = csr_matrix([[1,2,0],[0,0,3],[4,0,5]])
 |      >>> A.nonzero()
 |      (array([0, 0, 1, 2, 2]), array([0, 1, 2, 0, 2]))
 |  
 |  set_shape(self, shape)
 |      See `reshape`.
 |  
 |  setdiag(self, values, k=0)
 |      Set diagonal or off-diagonal elements of the array.
 |      
 |      Parameters
 |      ----------
 |      values : array_like
 |          New values of the diagonal elements.
 |      
 |          Values may have any length.  If the diagonal is longer than values,
 |          then the remaining diagonal entries will not be set.  If values if
 |          longer than the diagonal, then the remaining values are ignored.
 |      
 |          If a scalar value is given, all of the diagonal is set to it.
 |      
 |      k : int, optional
 |          Which off-diagonal to set, corresponding to elements a[i,i+k].
 |          Default: 0 (the main diagonal).
 |  
 |  sum(self, axis=None, dtype=None, out=None)
 |      Sum the matrix elements over a given axis.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the sum of all the matrix elements, returning a scalar
 |          (i.e. `axis` = `None`).
 |      dtype : dtype, optional
 |          The type of the returned matrix and of the accumulator in which
 |          the elements are summed.  The dtype of `a` is used by default
 |          unless `a` has an integer dtype of less precision than the default
 |          platform integer.  In that case, if `a` is signed then the platform
 |          integer is used while if `a` is unsigned then an unsigned integer
 |          of the same precision as the platform integer is used.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      out : np.matrix, optional
 |          Alternative output matrix in which to place the result. It must
 |          have the same shape as the expected output, but the type of the
 |          output values will be cast if necessary.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Returns
 |      -------
 |      sum_along_axis : np.matrix
 |          A matrix with the same shape as `self`, with the specified
 |          axis removed.
 |      
 |      See Also
 |      --------
 |      np.matrix.sum : NumPy's implementation of 'sum' for matrices
 |  
 |  tobsr(self, blocksize=None, copy=False)
 |      Convert this matrix to Block Sparse Row format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant bsr_matrix.
 |      
 |      When blocksize=(R, C) is provided, it will be used for construction of
 |      the bsr_matrix.
 |  
 |  todense(self, order=None, out=None)
 |      Return a dense matrix representation of this matrix.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F'}, optional
 |          Whether to store multi-dimensional data in C (row-major)
 |          or Fortran (column-major) order in memory. The default
 |          is 'None', indicating the NumPy default of C-ordered.
 |          Cannot be specified in conjunction with the `out`
 |          argument.
 |      
 |      out : ndarray, 2-dimensional, optional
 |          If specified, uses this array (or `numpy.matrix`) as the
 |          output buffer instead of allocating a new array to
 |          return. The provided array must have the same shape and
 |          dtype as the sparse matrix on which you are calling the
 |          method.
 |      
 |      Returns
 |      -------
 |      arr : numpy.matrix, 2-dimensional
 |          A NumPy matrix object with the same shape and containing
 |          the same data represented by the sparse matrix, with the
 |          requested memory order. If `out` was passed and was an
 |          array (rather than a `numpy.matrix`), it will be filled
 |          with the appropriate values and returned wrapped in a
 |          `numpy.matrix` object that shares the same memory.
 |  
 |  tolil(self, copy=False)
 |      Convert this matrix to LInked List format.
 |      
 |      With copy=False, the data/indices may be shared between this matrix and
 |      the resultant lil_matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from scipy.sparse.base.spmatrix:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  nnz
 |      Number of stored values, including explicit zeros.
 |      
 |      See also
 |      --------
 |      count_nonzero : Number of non-zero entries
 |  
 |  shape
 |      Get shape of a matrix.
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from scipy.sparse.base.spmatrix:
 |  
 |  __array_priority__ = 10.1
 |  
 |  __hash__ = None
 |  
 |  ndim = 2
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from scipy.sparse.data._minmax_mixin:
 |  
 |  argmax(self, axis=None, out=None)
 |      Return indices of maximum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several maximum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmax is computed. If None (default), index
 |          of the maximum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      ind : np.matrix or int
 |          Indices of maximum elements. If matrix, its size along `axis` is 1.
 |  
 |  argmin(self, axis=None, out=None)
 |      Return indices of minimum elements along an axis.
 |      
 |      Implicit zero elements are also taken into account. If there are
 |      several minimum values, the index of the first occurrence is returned.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None}, optional
 |          Axis along which the argmin is computed. If None (default), index
 |          of the minimum element in the flatten data is returned.
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |       ind : np.matrix or int
 |          Indices of minimum elements. If matrix, its size along `axis` is 1.
 |  
 |  max(self, axis=None, out=None)
 |      Return the maximum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the maximum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except
 |          for the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amax : coo_matrix or scalar
 |          Maximum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      min : The minimum value of a sparse matrix along a given axis.
 |      np.matrix.max : NumPy's implementation of 'max' for matrices
 |  
 |  min(self, axis=None, out=None)
 |      Return the minimum of the matrix or maximum along an axis.
 |      This takes all elements into account, not just the non-zero ones.
 |      
 |      Parameters
 |      ----------
 |      axis : {-2, -1, 0, 1, None} optional
 |          Axis along which the sum is computed. The default is to
 |          compute the minimum over all the matrix elements, returning
 |          a scalar (i.e. `axis` = `None`).
 |      
 |      out : None, optional
 |          This argument is in the signature *solely* for NumPy
 |          compatibility reasons. Do not pass in anything except for
 |          the default value, as this argument is not used.
 |      
 |      Returns
 |      -------
 |      amin : coo_matrix or scalar
 |          Minimum of `a`. If `axis` is None, the result is a scalar value.
 |          If `axis` is given, the result is a sparse.coo_matrix of dimension
 |          ``a.ndim - 1``.
 |      
 |      See Also
 |      --------
 |      max : The maximum value of a sparse matrix along a given axis.
 |      np.matrix.min : NumPy's implementation of 'min' for matrices
",class,"('self', 'arg1', 'shape', 'dtype', 'copy')","(nan, nan, None, None, False)","(nan, nan, 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, arg1, shape=None, dtype=None, copy=False)',)"
scipy,1.1.0,scipy.io.mmio.imag,io.mmio,imag,"Python Library Documentation: function imag in module numpy.lib.type_check

imag(val)
    Return the imaginary part of the complex argument.
    
    Parameters
    ----------
    val : array_like
        Input array.
    
    Returns
    -------
    out : ndarray or scalar
        The imaginary component of the complex argument. If `val` is real,
        the type of `val` is used for the output.  If `val` has complex
        elements, the returned type is float.
    
    See Also
    --------
    real, angle, real_if_close
    
    Examples
    --------
    >>> a = np.array([1+2j, 3+4j, 5+6j])
    >>> a.imag
    array([ 2.,  4.,  6.])
    >>> a.imag = np.array([8, 10, 12])
    >>> a
    array([ 1. +8.j,  3.+10.j,  5.+12.j])
    >>> np.imag(1 + 1j)
    1.0
",function,"('(val)',)",scipy,1.1.0,scipy.io.mmio.imag,io.mmio,imag,"Python Library Documentation: function imag in module numpy.lib.type_check

imag(val)
    Return the imaginary part of the complex argument.
    
    Parameters
    ----------
    val : array_like
        Input array.
    
    Returns
    -------
    out : ndarray or scalar
        The imaginary component of the complex argument. If `val` is real,
        the type of `val` is used for the output.  If `val` has complex
        elements, the returned type is float.
    
    See Also
    --------
    real, angle, real_if_close
    
    Examples
    --------
    >>> a = np.array([1+2j, 3+4j, 5+6j])
    >>> a.imag
    array([ 2.,  4.,  6.])
    >>> a.imag = np.array([8, 10, 12])
    >>> a
    array([ 1. +8.j,  3.+10.j,  5.+12.j])
    >>> np.imag(1 + 1j)
    1.0
",function,"('val',)","(nan,)","(nan,)","('arg_info',)","('(val)',)"
scipy,1.1.0,scipy.io.mmio.isspmatrix,io.mmio,isspmatrix,"Python Library Documentation: function isspmatrix in module scipy.sparse.base

isspmatrix(x)
    Is x of a sparse matrix type?
    
    Parameters
    ----------
    x
        object to check for being a sparse matrix
    
    Returns
    -------
    bool
        True if x is a sparse matrix, False otherwise
    
    Notes
    -----
    issparse and isspmatrix are aliases for the same function.
    
    Examples
    --------
    >>> from scipy.sparse import csr_matrix, isspmatrix
    >>> isspmatrix(csr_matrix([[5]]))
    True
    
    >>> from scipy.sparse import isspmatrix
    >>> isspmatrix(5)
    False
",function,"('(x)',)",scipy,1.1.0,scipy.io.mmio.isspmatrix,io.mmio,isspmatrix,"Python Library Documentation: function isspmatrix in module scipy.sparse.base

isspmatrix(x)
    Is x of a sparse matrix type?
    
    Parameters
    ----------
    x
        object to check for being a sparse matrix
    
    Returns
    -------
    bool
        True if x is a sparse matrix, False otherwise
    
    Notes
    -----
    issparse and isspmatrix are aliases for the same function.
    
    Examples
    --------
    >>> from scipy.sparse import csr_matrix, isspmatrix
    >>> isspmatrix(csr_matrix([[5]]))
    True
    
    >>> from scipy.sparse import isspmatrix
    >>> isspmatrix(5)
    False
",function,"('x',)","(nan,)","(nan,)","('arg_info',)","('(x)',)"
scipy,1.1.0,scipy.io.mmio.mminfo,io.mmio,mminfo,"Python Library Documentation: function mminfo in module scipy.io.mmio

mminfo(source)
    Return size and storage parameters from Matrix Market file-like 'source'.
    
    Parameters
    ----------
    source : str or file-like
        Matrix Market filename (extension .mtx) or open file-like object
    
    Returns
    -------
    rows : int
        Number of matrix rows.
    cols : int
        Number of matrix columns.
    entries : int
        Number of non-zero entries of a sparse matrix
        or rows*cols for a dense matrix.
    format : str
        Either 'coordinate' or 'array'.
    field : str
        Either 'real', 'complex', 'pattern', or 'integer'.
    symmetry : str
        Either 'general', 'symmetric', 'skew-symmetric', or 'hermitian'.
",function,"('(source)',)",scipy,1.1.0,scipy.io.mmio.mminfo,io.mmio,mminfo,"Python Library Documentation: function mminfo in module scipy.io.mmio

mminfo(source)
    Return size and storage parameters from Matrix Market file-like 'source'.
    
    Parameters
    ----------
    source : str or file-like
        Matrix Market filename (extension .mtx) or open file-like object
    
    Returns
    -------
    rows : int
        Number of matrix rows.
    cols : int
        Number of matrix columns.
    entries : int
        Number of non-zero entries of a sparse matrix
        or rows*cols for a dense matrix.
    format : str
        Either 'coordinate' or 'array'.
    field : str
        Either 'real', 'complex', 'pattern', or 'integer'.
    symmetry : str
        Either 'general', 'symmetric', 'skew-symmetric', or 'hermitian'.
",function,"('source',)","(nan,)","(nan,)","('arg_info',)","('(source)',)"
scipy,1.1.0,scipy.io.mmio.mmread,io.mmio,mmread,"Python Library Documentation: function mmread in module scipy.io.mmio

mmread(source)
    Reads the contents of a Matrix Market file-like 'source' into a matrix.
    
    Parameters
    ----------
    source : str or file-like
        Matrix Market filename (extensions .mtx, .mtz.gz)
        or open file-like object.
    
    Returns
    -------
    a : ndarray or coo_matrix
        Dense or sparse matrix depending on the matrix format in the
        Matrix Market file.
",function,"('(source)',)",scipy,1.1.0,scipy.io.mmio.mmread,io.mmio,mmread,"Python Library Documentation: function mmread in module scipy.io.mmio

mmread(source)
    Reads the contents of a Matrix Market file-like 'source' into a matrix.
    
    Parameters
    ----------
    source : str or file-like
        Matrix Market filename (extensions .mtx, .mtz.gz)
        or open file-like object.
    
    Returns
    -------
    a : ndarray or coo_matrix
        Dense or sparse matrix depending on the matrix format in the
        Matrix Market file.
",function,"('source',)","(nan,)","(nan,)","('arg_info',)","('(source)',)"
scipy,1.1.0,scipy.io.mmio.mmwrite,io.mmio,mmwrite,"Python Library Documentation: function mmwrite in module scipy.io.mmio

mmwrite(target, a, comment='', field=None, precision=None, symmetry=None)
    Writes the sparse or dense array `a` to Matrix Market file-like `target`.
    
    Parameters
    ----------
    target : str or file-like
        Matrix Market filename (extension .mtx) or open file-like object.
    a : array like
        Sparse or dense 2D array.
    comment : str, optional
        Comments to be prepended to the Matrix Market file.
    field : None or str, optional
        Either 'real', 'complex', 'pattern', or 'integer'.
    precision : None or int, optional
        Number of digits to display for real or complex values.
    symmetry : None or str, optional
        Either 'general', 'symmetric', 'skew-symmetric', or 'hermitian'.
        If symmetry is None the symmetry type of 'a' is determined by its
        values.
",function,"(""(target, a, comment='', field=None, precision=None, symmetry=None)"",)",scipy,1.1.0,scipy.io.mmio.mmwrite,io.mmio,mmwrite,"Python Library Documentation: function mmwrite in module scipy.io.mmio

mmwrite(target, a, comment='', field=None, precision=None, symmetry=None)
    Writes the sparse or dense array `a` to Matrix Market file-like `target`.
    
    Parameters
    ----------
    target : str or file-like
        Matrix Market filename (extension .mtx) or open file-like object.
    a : array like
        Sparse or dense 2D array.
    comment : str, optional
        Comments to be prepended to the Matrix Market file.
    field : None or str, optional
        Either 'real', 'complex', 'pattern', or 'integer'.
    precision : None or int, optional
        Number of digits to display for real or complex values.
    symmetry : None or str, optional
        Either 'general', 'symmetric', 'skew-symmetric', or 'hermitian'.
        If symmetry is None the symmetry type of 'a' is determined by its
        values.
",function,"('target', 'a', 'comment', 'field', 'precision', 'symmetry')","(nan, nan, '', None, None, None)","(nan, nan, nan, 'NoneType', 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(target, a, comment='', field=None, precision=None, symmetry=None)"",)"
scipy,1.1.0,scipy.io.mmio.ndarray,io.mmio,ndarray,"Python Library Documentation: class ndarray in module numpy

class ndarray(builtins.object)
 |  ndarray(shape, dtype=float, buffer=None, offset=0,
 |          strides=None, order=None)
 |  
 |  An array object represents a multidimensional, homogeneous array
 |  of fixed-size items.  An associated data-type object describes the
 |  format of each element in the array (its byte-order, how many bytes it
 |  occupies in memory, whether it is an integer, a floating point number,
 |  or something else, etc.)
 |  
 |  Arrays should be constructed using `array`, `zeros` or `empty` (refer
 |  to the See Also section below).  The parameters given here refer to
 |  a low-level method (`ndarray(...)`) for instantiating an array.
 |  
 |  For more information, refer to the `numpy` module and examine the
 |  methods and attributes of an array.
 |  
 |  Parameters
 |  ----------
 |  (for the __new__ method; see Notes below)
 |  
 |  shape : tuple of ints
 |      Shape of created array.
 |  dtype : data-type, optional
 |      Any object that can be interpreted as a numpy data type.
 |  buffer : object exposing buffer interface, optional
 |      Used to fill the array with data.
 |  offset : int, optional
 |      Offset of array data in buffer.
 |  strides : tuple of ints, optional
 |      Strides of data in memory.
 |  order : {'C', 'F'}, optional
 |      Row-major (C-style) or column-major (Fortran-style) order.
 |  
 |  Attributes
 |  ----------
 |  T : ndarray
 |      Transpose of the array.
 |  data : buffer
 |      The array's elements, in memory.
 |  dtype : dtype object
 |      Describes the format of the elements in the array.
 |  flags : dict
 |      Dictionary containing information related to memory use, e.g.,
 |      'C_CONTIGUOUS', 'OWNDATA', 'WRITEABLE', etc.
 |  flat : numpy.flatiter object
 |      Flattened version of the array as an iterator.  The iterator
 |      allows assignments, e.g., ``x.flat = 3`` (See `ndarray.flat` for
 |      assignment examples; TODO).
 |  imag : ndarray
 |      Imaginary part of the array.
 |  real : ndarray
 |      Real part of the array.
 |  size : int
 |      Number of elements in the array.
 |  itemsize : int
 |      The memory use of each array element in bytes.
 |  nbytes : int
 |      The total number of bytes required to store the array data,
 |      i.e., ``itemsize * size``.
 |  ndim : int
 |      The array's number of dimensions.
 |  shape : tuple of ints
 |      Shape of the array.
 |  strides : tuple of ints
 |      The step-size required to move from one element to the next in
 |      memory. For example, a contiguous ``(3, 4)`` array of type
 |      ``int16`` in C-order has strides ``(8, 2)``.  This implies that
 |      to move from element to element in memory requires jumps of 2 bytes.
 |      To move from row-to-row, one needs to jump 8 bytes at a time
 |      (``2 * 4``).
 |  ctypes : ctypes object
 |      Class containing properties of the array needed for interaction
 |      with ctypes.
 |  base : ndarray
 |      If the array is a view into another array, that array is its `base`
 |      (unless that array is also a view).  The `base` array is where the
 |      array data is actually stored.
 |  
 |  See Also
 |  --------
 |  array : Construct an array.
 |  zeros : Create an array, each element of which is zero.
 |  empty : Create an array, but leave its allocated memory unchanged (i.e.,
 |          it contains ""garbage"").
 |  dtype : Create a data-type.
 |  
 |  Notes
 |  -----
 |  There are two modes of creating an array using ``__new__``:
 |  
 |  1. If `buffer` is None, then only `shape`, `dtype`, and `order`
 |     are used.
 |  2. If `buffer` is an object exposing the buffer interface, then
 |     all keywords are interpreted.
 |  
 |  No ``__init__`` method is needed because the array is fully initialized
 |  after the ``__new__`` method.
 |  
 |  Examples
 |  --------
 |  These examples illustrate the low-level `ndarray` constructor.  Refer
 |  to the `See Also` section above for easier ways of constructing an
 |  ndarray.
 |  
 |  First mode, `buffer` is None:
 |  
 |  >>> np.ndarray(shape=(2,2), dtype=float, order='F')
 |  array([[ -1.13698227e+002,   4.25087011e-303],
 |         [  2.88528414e-306,   3.27025015e-309]])         #random
 |  
 |  Second mode:
 |  
 |  >>> np.ndarray((2,), buffer=np.array([1,2,3]),
 |  ...            offset=np.int_().itemsize,
 |  ...            dtype=int) # offset = 1*itemsize, i.e. skip first element
 |  array([2, 3])
 |  
 |  Methods defined here:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __array__(...)
 |      a.__array__(|dtype) -> reference if type unchanged, copy otherwise.
 |      
 |      Returns either a new reference to self if dtype is not given or a new array
 |      of provided data type if dtype is different from the current dtype of the
 |      array.
 |  
 |  __array_prepare__(...)
 |      a.__array_prepare__(obj) -> Object of same type as ndarray object obj.
 |  
 |  __array_ufunc__(...)
 |  
 |  __array_wrap__(...)
 |      a.__array_wrap__(obj) -> Object of same type as ndarray object a.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __complex__(...)
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __copy__(...)
 |      a.__copy__()
 |      
 |      Used if :func:`copy.copy` is called on an array. Returns a copy of the array.
 |      
 |      Equivalent to ``a.copy(order='K')``.
 |  
 |  __deepcopy__(...)
 |      a.__deepcopy__(memo, /) -> Deep copy of array.
 |      
 |      Used if :func:`copy.deepcopy` is called on an array.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __format__(...)
 |      default object formatter
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iadd__(self, value, /)
 |      Return self+=value.
 |  
 |  __iand__(self, value, /)
 |      Return self&=value.
 |  
 |  __ifloordiv__(self, value, /)
 |      Return self//=value.
 |  
 |  __ilshift__(self, value, /)
 |      Return self<<=value.
 |  
 |  __imatmul__(self, value, /)
 |      Return self@=value.
 |  
 |  __imod__(self, value, /)
 |      Return self%=value.
 |  
 |  __imul__(self, value, /)
 |      Return self*=value.
 |  
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __ior__(self, value, /)
 |      Return self|=value.
 |  
 |  __ipow__(self, value, /)
 |      Return self**=value.
 |  
 |  __irshift__(self, value, /)
 |      Return self>>=value.
 |  
 |  __isub__(self, value, /)
 |      Return self-=value.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __itruediv__(self, value, /)
 |      Return self/=value.
 |  
 |  __ixor__(self, value, /)
 |      Return self^=value.
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __matmul__(self, value, /)
 |      Return self@value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __reduce__(...)
 |      a.__reduce__()
 |      
 |      For pickling.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmatmul__(self, value, /)
 |      Return value@self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __setstate__(...)
 |      a.__setstate__(state, /)
 |      
 |      For unpickling.
 |      
 |      The `state` argument must be a sequence that contains the following
 |      elements:
 |      
 |      Parameters
 |      ----------
 |      version : int
 |          optional pickle version. If omitted defaults to 0.
 |      shape : tuple
 |      dtype : data-type
 |      isFortran : bool
 |      rawdata : string or list
 |          a binary string with the data (or a list if 'a' is an object array)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  all(...)
 |      a.all(axis=None, out=None, keepdims=False)
 |      
 |      Returns True if all elements evaluate to True.
 |      
 |      Refer to `numpy.all` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.all : equivalent function
 |  
 |  any(...)
 |      a.any(axis=None, out=None, keepdims=False)
 |      
 |      Returns True if any of the elements of `a` evaluate to True.
 |      
 |      Refer to `numpy.any` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.any : equivalent function
 |  
 |  argmax(...)
 |      a.argmax(axis=None, out=None)
 |      
 |      Return indices of the maximum values along the given axis.
 |      
 |      Refer to `numpy.argmax` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argmax : equivalent function
 |  
 |  argmin(...)
 |      a.argmin(axis=None, out=None)
 |      
 |      Return indices of the minimum values along the given axis of `a`.
 |      
 |      Refer to `numpy.argmin` for detailed documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argmin : equivalent function
 |  
 |  argpartition(...)
 |      a.argpartition(kth, axis=-1, kind='introselect', order=None)
 |      
 |      Returns the indices that would partition this array.
 |      
 |      Refer to `numpy.argpartition` for full documentation.
 |      
 |      .. versionadded:: 1.8.0
 |      
 |      See Also
 |      --------
 |      numpy.argpartition : equivalent function
 |  
 |  argsort(...)
 |      a.argsort(axis=-1, kind='quicksort', order=None)
 |      
 |      Returns the indices that would sort this array.
 |      
 |      Refer to `numpy.argsort` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argsort : equivalent function
 |  
 |  astype(...)
 |      a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)
 |      
 |      Copy of the array, cast to a specified type.
 |      
 |      Parameters
 |      ----------
 |      dtype : str or dtype
 |          Typecode or data-type to which the array is cast.
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          Controls the memory layout order of the result.
 |          'C' means C order, 'F' means Fortran order, 'A'
 |          means 'F' order if all the arrays are Fortran contiguous,
 |          'C' order otherwise, and 'K' means as close to the
 |          order the array elements appear in memory as possible.
 |          Default is 'K'.
 |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
 |          Controls what kind of data casting may occur. Defaults to 'unsafe'
 |          for backwards compatibility.
 |      
 |            * 'no' means the data types should not be cast at all.
 |            * 'equiv' means only byte-order changes are allowed.
 |            * 'safe' means only casts which can preserve values are allowed.
 |            * 'same_kind' means only safe casts or casts within a kind,
 |              like float64 to float32, are allowed.
 |            * 'unsafe' means any data conversions may be done.
 |      subok : bool, optional
 |          If True, then sub-classes will be passed-through (default), otherwise
 |          the returned array will be forced to be a base-class array.
 |      copy : bool, optional
 |          By default, astype always returns a newly allocated array. If this
 |          is set to false, and the `dtype`, `order`, and `subok`
 |          requirements are satisfied, the input array is returned instead
 |          of a copy.
 |      
 |      Returns
 |      -------
 |      arr_t : ndarray
 |          Unless `copy` is False and the other conditions for returning the input
 |          array are satisfied (see description for `copy` input parameter), `arr_t`
 |          is a new array of the same shape as the input array, with dtype, order
 |          given by `dtype`, `order`.
 |      
 |      Notes
 |      -----
 |      Starting in NumPy 1.9, astype method now returns an error if the string
 |      dtype to cast to is not long enough in 'safe' casting mode to hold the max
 |      value of integer/float array that is being casted. Previously the casting
 |      was allowed even if the result was truncated.
 |      
 |      Raises
 |      ------
 |      ComplexWarning
 |          When casting from complex to float or int. To avoid this,
 |          one should use ``a.real.astype(t)``.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 2.5])
 |      >>> x
 |      array([ 1. ,  2. ,  2.5])
 |      
 |      >>> x.astype(int)
 |      array([1, 2, 2])
 |  
 |  byteswap(...)
 |      a.byteswap(inplace=False)
 |      
 |      Swap the bytes of the array elements
 |      
 |      Toggle between low-endian and big-endian data representation by
 |      returning a byteswapped array, optionally swapped in-place.
 |      
 |      Parameters
 |      ----------
 |      inplace : bool, optional
 |          If ``True``, swap bytes in-place, default is ``False``.
 |      
 |      Returns
 |      -------
 |      out : ndarray
 |          The byteswapped array. If `inplace` is ``True``, this is
 |          a view to self.
 |      
 |      Examples
 |      --------
 |      >>> A = np.array([1, 256, 8755], dtype=np.int16)
 |      >>> map(hex, A)
 |      ['0x1', '0x100', '0x2233']
 |      >>> A.byteswap(inplace=True)
 |      array([  256,     1, 13090], dtype=int16)
 |      >>> map(hex, A)
 |      ['0x100', '0x1', '0x3322']
 |      
 |      Arrays of strings are not swapped
 |      
 |      >>> A = np.array(['ceg', 'fac'])
 |      >>> A.byteswap()
 |      array(['ceg', 'fac'],
 |            dtype='|S3')
 |  
 |  choose(...)
 |      a.choose(choices, out=None, mode='raise')
 |      
 |      Use an index array to construct a new array from a set of choices.
 |      
 |      Refer to `numpy.choose` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.choose : equivalent function
 |  
 |  clip(...)
 |      a.clip(min=None, max=None, out=None)
 |      
 |      Return an array whose values are limited to ``[min, max]``.
 |      One of max or min must be given.
 |      
 |      Refer to `numpy.clip` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.clip : equivalent function
 |  
 |  compress(...)
 |      a.compress(condition, axis=None, out=None)
 |      
 |      Return selected slices of this array along given axis.
 |      
 |      Refer to `numpy.compress` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.compress : equivalent function
 |  
 |  conj(...)
 |      a.conj()
 |      
 |      Complex-conjugate all elements.
 |      
 |      Refer to `numpy.conjugate` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.conjugate : equivalent function
 |  
 |  conjugate(...)
 |      a.conjugate()
 |      
 |      Return the complex conjugate, element-wise.
 |      
 |      Refer to `numpy.conjugate` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.conjugate : equivalent function
 |  
 |  copy(...)
 |      a.copy(order='C')
 |      
 |      Return a copy of the array.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          Controls the memory layout of the copy. 'C' means C-order,
 |          'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
 |          'C' otherwise. 'K' means match the layout of `a` as closely
 |          as possible. (Note that this function and :func:`numpy.copy` are very
 |          similar, but have different default values for their order=
 |          arguments.)
 |      
 |      See also
 |      --------
 |      numpy.copy
 |      numpy.copyto
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[1,2,3],[4,5,6]], order='F')
 |      
 |      >>> y = x.copy()
 |      
 |      >>> x.fill(0)
 |      
 |      >>> x
 |      array([[0, 0, 0],
 |             [0, 0, 0]])
 |      
 |      >>> y
 |      array([[1, 2, 3],
 |             [4, 5, 6]])
 |      
 |      >>> y.flags['C_CONTIGUOUS']
 |      True
 |  
 |  cumprod(...)
 |      a.cumprod(axis=None, dtype=None, out=None)
 |      
 |      Return the cumulative product of the elements along the given axis.
 |      
 |      Refer to `numpy.cumprod` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.cumprod : equivalent function
 |  
 |  cumsum(...)
 |      a.cumsum(axis=None, dtype=None, out=None)
 |      
 |      Return the cumulative sum of the elements along the given axis.
 |      
 |      Refer to `numpy.cumsum` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.cumsum : equivalent function
 |  
 |  diagonal(...)
 |      a.diagonal(offset=0, axis1=0, axis2=1)
 |      
 |      Return specified diagonals. In NumPy 1.9 the returned array is a
 |      read-only view instead of a copy as in previous NumPy versions.  In
 |      a future version the read-only restriction will be removed.
 |      
 |      Refer to :func:`numpy.diagonal` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.diagonal : equivalent function
 |  
 |  dot(...)
 |      a.dot(b, out=None)
 |      
 |      Dot product of two arrays.
 |      
 |      Refer to `numpy.dot` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.dot : equivalent function
 |      
 |      Examples
 |      --------
 |      >>> a = np.eye(2)
 |      >>> b = np.ones((2, 2)) * 2
 |      >>> a.dot(b)
 |      array([[ 2.,  2.],
 |             [ 2.,  2.]])
 |      
 |      This array method can be conveniently chained:
 |      
 |      >>> a.dot(b).dot(b)
 |      array([[ 8.,  8.],
 |             [ 8.,  8.]])
 |  
 |  dump(...)
 |      a.dump(file)
 |      
 |      Dump a pickle of the array to the specified file.
 |      The array can be read back with pickle.load or numpy.load.
 |      
 |      Parameters
 |      ----------
 |      file : str
 |          A string naming the dump file.
 |  
 |  dumps(...)
 |      a.dumps()
 |      
 |      Returns the pickle of the array as a string.
 |      pickle.loads or numpy.loads will convert the string back to an array.
 |      
 |      Parameters
 |      ----------
 |      None
 |  
 |  fill(...)
 |      a.fill(value)
 |      
 |      Fill the array with a scalar value.
 |      
 |      Parameters
 |      ----------
 |      value : scalar
 |          All elements of `a` will be assigned this value.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([1, 2])
 |      >>> a.fill(0)
 |      >>> a
 |      array([0, 0])
 |      >>> a = np.empty(2)
 |      >>> a.fill(1)
 |      >>> a
 |      array([ 1.,  1.])
 |  
 |  flatten(...)
 |      a.flatten(order='C')
 |      
 |      Return a copy of the array collapsed into one dimension.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          'C' means to flatten in row-major (C-style) order.
 |          'F' means to flatten in column-major (Fortran-
 |          style) order. 'A' means to flatten in column-major
 |          order if `a` is Fortran *contiguous* in memory,
 |          row-major order otherwise. 'K' means to flatten
 |          `a` in the order the elements occur in memory.
 |          The default is 'C'.
 |      
 |      Returns
 |      -------
 |      y : ndarray
 |          A copy of the input array, flattened to one dimension.
 |      
 |      See Also
 |      --------
 |      ravel : Return a flattened array.
 |      flat : A 1-D flat iterator over the array.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1,2], [3,4]])
 |      >>> a.flatten()
 |      array([1, 2, 3, 4])
 |      >>> a.flatten('F')
 |      array([1, 3, 2, 4])
 |  
 |  getfield(...)
 |      a.getfield(dtype, offset=0)
 |      
 |      Returns a field of the given array as a certain type.
 |      
 |      A field is a view of the array data with a given data-type. The values in
 |      the view are determined by the given type and the offset into the current
 |      array in bytes. The offset needs to be such that the view dtype fits in the
 |      array dtype; for example an array of dtype complex128 has 16-byte elements.
 |      If taking a view with a 32-bit integer (4 bytes), the offset needs to be
 |      between 0 and 12 bytes.
 |      
 |      Parameters
 |      ----------
 |      dtype : str or dtype
 |          The data type of the view. The dtype size of the view can not be larger
 |          than that of the array itself.
 |      offset : int
 |          Number of bytes to skip before beginning the element view.
 |      
 |      Examples
 |      --------
 |      >>> x = np.diag([1.+1.j]*2)
 |      >>> x[1, 1] = 2 + 4.j
 |      >>> x
 |      array([[ 1.+1.j,  0.+0.j],
 |             [ 0.+0.j,  2.+4.j]])
 |      >>> x.getfield(np.float64)
 |      array([[ 1.,  0.],
 |             [ 0.,  2.]])
 |      
 |      By choosing an offset of 8 bytes we can select the complex part of the
 |      array for our view:
 |      
 |      >>> x.getfield(np.float64, offset=8)
 |      array([[ 1.,  0.],
 |         [ 0.,  4.]])
 |  
 |  item(...)
 |      a.item(*args)
 |      
 |      Copy an element of an array to a standard Python scalar and return it.
 |      
 |      Parameters
 |      ----------
 |      \*args : Arguments (variable number and type)
 |      
 |          * none: in this case, the method only works for arrays
 |            with one element (`a.size == 1`), which element is
 |            copied into a standard Python scalar object and returned.
 |      
 |          * int_type: this argument is interpreted as a flat index into
 |            the array, specifying which element to copy and return.
 |      
 |          * tuple of int_types: functions as does a single int_type argument,
 |            except that the argument is interpreted as an nd-index into the
 |            array.
 |      
 |      Returns
 |      -------
 |      z : Standard Python scalar object
 |          A copy of the specified element of the array as a suitable
 |          Python scalar
 |      
 |      Notes
 |      -----
 |      When the data type of `a` is longdouble or clongdouble, item() returns
 |      a scalar array object because there is no available Python scalar that
 |      would not lose information. Void arrays return a buffer object for item(),
 |      unless fields are defined, in which case a tuple is returned.
 |      
 |      `item` is very similar to a[args], except, instead of an array scalar,
 |      a standard Python scalar is returned. This can be useful for speeding up
 |      access to elements of the array and doing arithmetic on elements of the
 |      array using Python's optimized math.
 |      
 |      Examples
 |      --------
 |      >>> x = np.random.randint(9, size=(3, 3))
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 8, 3],
 |             [8, 5, 3]])
 |      >>> x.item(3)
 |      2
 |      >>> x.item(7)
 |      5
 |      >>> x.item((0, 1))
 |      1
 |      >>> x.item((2, 2))
 |      3
 |  
 |  itemset(...)
 |      a.itemset(*args)
 |      
 |      Insert scalar into an array (scalar is cast to array's dtype, if possible)
 |      
 |      There must be at least 1 argument, and define the last argument
 |      as *item*.  Then, ``a.itemset(*args)`` is equivalent to but faster
 |      than ``a[args] = item``.  The item should be a scalar value and `args`
 |      must select a single item in the array `a`.
 |      
 |      Parameters
 |      ----------
 |      \*args : Arguments
 |          If one argument: a scalar, only used in case `a` is of size 1.
 |          If two arguments: the last argument is the value to be set
 |          and must be a scalar, the first argument specifies a single array
 |          element location. It is either an int or a tuple.
 |      
 |      Notes
 |      -----
 |      Compared to indexing syntax, `itemset` provides some speed increase
 |      for placing a scalar into a particular location in an `ndarray`,
 |      if you must do this.  However, generally this is discouraged:
 |      among other problems, it complicates the appearance of the code.
 |      Also, when using `itemset` (and `item`) inside a loop, be sure
 |      to assign the methods to a local variable to avoid the attribute
 |      look-up at each loop iteration.
 |      
 |      Examples
 |      --------
 |      >>> x = np.random.randint(9, size=(3, 3))
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 8, 3],
 |             [8, 5, 3]])
 |      >>> x.itemset(4, 0)
 |      >>> x.itemset((2, 2), 9)
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 0, 3],
 |             [8, 5, 9]])
 |  
 |  max(...)
 |      a.max(axis=None, out=None, keepdims=False)
 |      
 |      Return the maximum along a given axis.
 |      
 |      Refer to `numpy.amax` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.amax : equivalent function
 |  
 |  mean(...)
 |      a.mean(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Returns the average of the array elements along given axis.
 |      
 |      Refer to `numpy.mean` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.mean : equivalent function
 |  
 |  min(...)
 |      a.min(axis=None, out=None, keepdims=False)
 |      
 |      Return the minimum along a given axis.
 |      
 |      Refer to `numpy.amin` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.amin : equivalent function
 |  
 |  newbyteorder(...)
 |      arr.newbyteorder(new_order='S')
 |      
 |      Return the array with the same data viewed with a different byte order.
 |      
 |      Equivalent to::
 |      
 |          arr.view(arr.dtype.newbytorder(new_order))
 |      
 |      Changes are also made in all fields and sub-arrays of the array data
 |      type.
 |      
 |      
 |      
 |      Parameters
 |      ----------
 |      new_order : string, optional
 |          Byte order to force; a value from the byte order specifications
 |          below. `new_order` codes can be any of:
 |      
 |          * 'S' - swap dtype from current to opposite endian
 |          * {'<', 'L'} - little endian
 |          * {'>', 'B'} - big endian
 |          * {'=', 'N'} - native order
 |          * {'|', 'I'} - ignore (no change to byte order)
 |      
 |          The default value ('S') results in swapping the current
 |          byte order. The code does a case-insensitive check on the first
 |          letter of `new_order` for the alternatives above.  For example,
 |          any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 |      
 |      
 |      Returns
 |      -------
 |      new_arr : array
 |          New array object with the dtype reflecting given change to the
 |          byte order.
 |  
 |  nonzero(...)
 |      a.nonzero()
 |      
 |      Return the indices of the elements that are non-zero.
 |      
 |      Refer to `numpy.nonzero` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.nonzero : equivalent function
 |  
 |  partition(...)
 |      a.partition(kth, axis=-1, kind='introselect', order=None)
 |      
 |      Rearranges the elements in the array in such a way that value of the
 |      element in kth position is in the position it would be in a sorted array.
 |      All elements smaller than the kth element are moved before this element and
 |      all equal or greater are moved behind it. The ordering of the elements in
 |      the two partitions is undefined.
 |      
 |      .. versionadded:: 1.8.0
 |      
 |      Parameters
 |      ----------
 |      kth : int or sequence of ints
 |          Element index to partition by. The kth element value will be in its
 |          final sorted position and all smaller elements will be moved before it
 |          and all equal or greater elements behind it.
 |          The order all elements in the partitions is undefined.
 |          If provided with a sequence of kth it will partition all elements
 |          indexed by kth of them into their sorted position at once.
 |      axis : int, optional
 |          Axis along which to sort. Default is -1, which means sort along the
 |          last axis.
 |      kind : {'introselect'}, optional
 |          Selection algorithm. Default is 'introselect'.
 |      order : str or list of str, optional
 |          When `a` is an array with fields defined, this argument specifies
 |          which fields to compare first, second, etc.  A single field can
 |          be specified as a string, and not all fields need be specified,
 |          but unspecified fields will still be used, in the order in which
 |          they come up in the dtype, to break ties.
 |      
 |      See Also
 |      --------
 |      numpy.partition : Return a parititioned copy of an array.
 |      argpartition : Indirect partition.
 |      sort : Full sort.
 |      
 |      Notes
 |      -----
 |      See ``np.partition`` for notes on the different algorithms.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([3, 4, 2, 1])
 |      >>> a.partition(3)
 |      >>> a
 |      array([2, 1, 3, 4])
 |      
 |      >>> a.partition((1, 3))
 |      array([1, 2, 3, 4])
 |  
 |  prod(...)
 |      a.prod(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Return the product of the array elements over the given axis
 |      
 |      Refer to `numpy.prod` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.prod : equivalent function
 |  
 |  ptp(...)
 |      a.ptp(axis=None, out=None)
 |      
 |      Peak to peak (maximum - minimum) value along a given axis.
 |      
 |      Refer to `numpy.ptp` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.ptp : equivalent function
 |  
 |  put(...)
 |      a.put(indices, values, mode='raise')
 |      
 |      Set ``a.flat[n] = values[n]`` for all `n` in indices.
 |      
 |      Refer to `numpy.put` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.put : equivalent function
 |  
 |  ravel(...)
 |      a.ravel([order])
 |      
 |      Return a flattened array.
 |      
 |      Refer to `numpy.ravel` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.ravel : equivalent function
 |      
 |      ndarray.flat : a flat iterator on the array.
 |  
 |  repeat(...)
 |      a.repeat(repeats, axis=None)
 |      
 |      Repeat elements of an array.
 |      
 |      Refer to `numpy.repeat` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.repeat : equivalent function
 |  
 |  reshape(...)
 |      a.reshape(shape, order='C')
 |      
 |      Returns an array containing the same data with a new shape.
 |      
 |      Refer to `numpy.reshape` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.reshape : equivalent function
 |      
 |      Notes
 |      -----
 |      Unlike the free function `numpy.reshape`, this method on `ndarray` allows
 |      the elements of the shape parameter to be passed in as separate arguments.
 |      For example, ``a.reshape(10, 11)`` is equivalent to
 |      ``a.reshape((10, 11))``.
 |  
 |  resize(...)
 |      a.resize(new_shape, refcheck=True)
 |      
 |      Change shape and size of array in-place.
 |      
 |      Parameters
 |      ----------
 |      new_shape : tuple of ints, or `n` ints
 |          Shape of resized array.
 |      refcheck : bool, optional
 |          If False, reference count will not be checked. Default is True.
 |      
 |      Returns
 |      -------
 |      None
 |      
 |      Raises
 |      ------
 |      ValueError
 |          If `a` does not own its own data or references or views to it exist,
 |          and the data memory must be changed.
 |          PyPy only: will always raise if the data memory must be changed, since
 |          there is no reliable way to determine if references or views to it
 |          exist.
 |      
 |      SystemError
 |          If the `order` keyword argument is specified. This behaviour is a
 |          bug in NumPy.
 |      
 |      See Also
 |      --------
 |      resize : Return a new array with the specified shape.
 |      
 |      Notes
 |      -----
 |      This reallocates space for the data area if necessary.
 |      
 |      Only contiguous arrays (data elements consecutive in memory) can be
 |      resized.
 |      
 |      The purpose of the reference count check is to make sure you
 |      do not use this array as a buffer for another Python object and then
 |      reallocate the memory. However, reference counts can increase in
 |      other ways so if you are sure that you have not shared the memory
 |      for this array with another Python object, then you may safely set
 |      `refcheck` to False.
 |      
 |      Examples
 |      --------
 |      Shrinking an array: array is flattened (in the order that the data are
 |      stored in memory), resized, and reshaped:
 |      
 |      >>> a = np.array([[0, 1], [2, 3]], order='C')
 |      >>> a.resize((2, 1))
 |      >>> a
 |      array([[0],
 |             [1]])
 |      
 |      >>> a = np.array([[0, 1], [2, 3]], order='F')
 |      >>> a.resize((2, 1))
 |      >>> a
 |      array([[0],
 |             [2]])
 |      
 |      Enlarging an array: as above, but missing entries are filled with zeros:
 |      
 |      >>> b = np.array([[0, 1], [2, 3]])
 |      >>> b.resize(2, 3) # new_shape parameter doesn't have to be a tuple
 |      >>> b
 |      array([[0, 1, 2],
 |             [3, 0, 0]])
 |      
 |      Referencing an array prevents resizing...
 |      
 |      >>> c = a
 |      >>> a.resize((1, 1))
 |      Traceback (most recent call last):
 |      ...
 |      ValueError: cannot resize an array that has been referenced ...
 |      
 |      Unless `refcheck` is False:
 |      
 |      >>> a.resize((1, 1), refcheck=False)
 |      >>> a
 |      array([[0]])
 |      >>> c
 |      array([[0]])
 |  
 |  round(...)
 |      a.round(decimals=0, out=None)
 |      
 |      Return `a` with each element rounded to the given number of decimals.
 |      
 |      Refer to `numpy.around` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.around : equivalent function
 |  
 |  searchsorted(...)
 |      a.searchsorted(v, side='left', sorter=None)
 |      
 |      Find indices where elements of v should be inserted in a to maintain order.
 |      
 |      For full documentation, see `numpy.searchsorted`
 |      
 |      See Also
 |      --------
 |      numpy.searchsorted : equivalent function
 |  
 |  setfield(...)
 |      a.setfield(val, dtype, offset=0)
 |      
 |      Put a value into a specified place in a field defined by a data-type.
 |      
 |      Place `val` into `a`'s field defined by `dtype` and beginning `offset`
 |      bytes into the field.
 |      
 |      Parameters
 |      ----------
 |      val : object
 |          Value to be placed in field.
 |      dtype : dtype object
 |          Data-type of the field in which to place `val`.
 |      offset : int, optional
 |          The number of bytes into the field at which to place `val`.
 |      
 |      Returns
 |      -------
 |      None
 |      
 |      See Also
 |      --------
 |      getfield
 |      
 |      Examples
 |      --------
 |      >>> x = np.eye(3)
 |      >>> x.getfield(np.float64)
 |      array([[ 1.,  0.,  0.],
 |             [ 0.,  1.,  0.],
 |             [ 0.,  0.,  1.]])
 |      >>> x.setfield(3, np.int32)
 |      >>> x.getfield(np.int32)
 |      array([[3, 3, 3],
 |             [3, 3, 3],
 |             [3, 3, 3]])
 |      >>> x
 |      array([[  1.00000000e+000,   1.48219694e-323,   1.48219694e-323],
 |             [  1.48219694e-323,   1.00000000e+000,   1.48219694e-323],
 |             [  1.48219694e-323,   1.48219694e-323,   1.00000000e+000]])
 |      >>> x.setfield(np.eye(3), np.int32)
 |      >>> x
 |      array([[ 1.,  0.,  0.],
 |             [ 0.,  1.,  0.],
 |             [ 0.,  0.,  1.]])
 |  
 |  setflags(...)
 |      a.setflags(write=None, align=None, uic=None)
 |      
 |      Set array flags WRITEABLE, ALIGNED, (WRITEBACKIFCOPY and UPDATEIFCOPY),
 |      respectively.
 |      
 |      These Boolean-valued flags affect how numpy interprets the memory
 |      area used by `a` (see Notes below). The ALIGNED flag can only
 |      be set to True if the data is actually aligned according to the type.
 |      The WRITEBACKIFCOPY and (deprecated) UPDATEIFCOPY flags can never be set
 |      to True. The flag WRITEABLE can only be set to True if the array owns its
 |      own memory, or the ultimate owner of the memory exposes a writeable buffer
 |      interface, or is a string. (The exception for string is made so that
 |      unpickling can be done without copying memory.)
 |      
 |      Parameters
 |      ----------
 |      write : bool, optional
 |          Describes whether or not `a` can be written to.
 |      align : bool, optional
 |          Describes whether or not `a` is aligned properly for its type.
 |      uic : bool, optional
 |          Describes whether or not `a` is a copy of another ""base"" array.
 |      
 |      Notes
 |      -----
 |      Array flags provide information about how the memory area used
 |      for the array is to be interpreted. There are 7 Boolean flags
 |      in use, only four of which can be changed by the user:
 |      WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED.
 |      
 |      WRITEABLE (W) the data area can be written to;
 |      
 |      ALIGNED (A) the data and strides are aligned appropriately for the hardware
 |      (as determined by the compiler);
 |      
 |      UPDATEIFCOPY (U) (deprecated), replaced by WRITEBACKIFCOPY;
 |      
 |      WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced
 |      by .base). When the C-API function PyArray_ResolveWritebackIfCopy is
 |      called, the base array will be updated with the contents of this array.
 |      
 |      All flags can be accessed using the single (upper case) letter as well
 |      as the full name.
 |      
 |      Examples
 |      --------
 |      >>> y
 |      array([[3, 1, 7],
 |             [2, 0, 0],
 |             [8, 5, 9]])
 |      >>> y.flags
 |        C_CONTIGUOUS : True
 |        F_CONTIGUOUS : False
 |        OWNDATA : True
 |        WRITEABLE : True
 |        ALIGNED : True
 |        WRITEBACKIFCOPY : False
 |        UPDATEIFCOPY : False
 |      >>> y.setflags(write=0, align=0)
 |      >>> y.flags
 |        C_CONTIGUOUS : True
 |        F_CONTIGUOUS : False
 |        OWNDATA : True
 |        WRITEABLE : False
 |        ALIGNED : False
 |        WRITEBACKIFCOPY : False
 |        UPDATEIFCOPY : False
 |      >>> y.setflags(uic=1)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: cannot set WRITEBACKIFCOPY flag to True
 |  
 |  sort(...)
 |      a.sort(axis=-1, kind='quicksort', order=None)
 |      
 |      Sort an array, in-place.
 |      
 |      Parameters
 |      ----------
 |      axis : int, optional
 |          Axis along which to sort. Default is -1, which means sort along the
 |          last axis.
 |      kind : {'quicksort', 'mergesort', 'heapsort'}, optional
 |          Sorting algorithm. Default is 'quicksort'.
 |      order : str or list of str, optional
 |          When `a` is an array with fields defined, this argument specifies
 |          which fields to compare first, second, etc.  A single field can
 |          be specified as a string, and not all fields need be specified,
 |          but unspecified fields will still be used, in the order in which
 |          they come up in the dtype, to break ties.
 |      
 |      See Also
 |      --------
 |      numpy.sort : Return a sorted copy of an array.
 |      argsort : Indirect sort.
 |      lexsort : Indirect stable sort on multiple keys.
 |      searchsorted : Find elements in sorted array.
 |      partition: Partial sort.
 |      
 |      Notes
 |      -----
 |      See ``sort`` for notes on the different sorting algorithms.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1,4], [3,1]])
 |      >>> a.sort(axis=1)
 |      >>> a
 |      array([[1, 4],
 |             [1, 3]])
 |      >>> a.sort(axis=0)
 |      >>> a
 |      array([[1, 3],
 |             [1, 4]])
 |      
 |      Use the `order` keyword to specify a field to use when sorting a
 |      structured array:
 |      
 |      >>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])
 |      >>> a.sort(order='y')
 |      >>> a
 |      array([('c', 1), ('a', 2)],
 |            dtype=[('x', '|S1'), ('y', '<i4')])
 |  
 |  squeeze(...)
 |      a.squeeze(axis=None)
 |      
 |      Remove single-dimensional entries from the shape of `a`.
 |      
 |      Refer to `numpy.squeeze` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.squeeze : equivalent function
 |  
 |  std(...)
 |      a.std(axis=None, dtype=None, out=None, ddof=0, keepdims=False)
 |      
 |      Returns the standard deviation of the array elements along given axis.
 |      
 |      Refer to `numpy.std` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.std : equivalent function
 |  
 |  sum(...)
 |      a.sum(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Return the sum of the array elements over the given axis.
 |      
 |      Refer to `numpy.sum` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.sum : equivalent function
 |  
 |  swapaxes(...)
 |      a.swapaxes(axis1, axis2)
 |      
 |      Return a view of the array with `axis1` and `axis2` interchanged.
 |      
 |      Refer to `numpy.swapaxes` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.swapaxes : equivalent function
 |  
 |  take(...)
 |      a.take(indices, axis=None, out=None, mode='raise')
 |      
 |      Return an array formed from the elements of `a` at the given indices.
 |      
 |      Refer to `numpy.take` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.take : equivalent function
 |  
 |  tobytes(...)
 |      a.tobytes(order='C')
 |      
 |      Construct Python bytes containing the raw data bytes in the array.
 |      
 |      Constructs Python bytes showing a copy of the raw contents of
 |      data memory. The bytes object can be produced in either 'C' or 'Fortran',
 |      or 'Any' order (the default is 'C'-order). 'Any' order means C-order
 |      unless the F_CONTIGUOUS flag in the array is set, in which case it
 |      means 'Fortran' order.
 |      
 |      .. versionadded:: 1.9.0
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', None}, optional
 |          Order of the data for multidimensional arrays:
 |          C, Fortran, or the same as for the original array.
 |      
 |      Returns
 |      -------
 |      s : bytes
 |          Python bytes exhibiting a copy of `a`'s raw data.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[0, 1], [2, 3]])
 |      >>> x.tobytes()
 |      b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
 |      >>> x.tobytes('C') == x.tobytes()
 |      True
 |      >>> x.tobytes('F')
 |      b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
 |  
 |  tofile(...)
 |      a.tofile(fid, sep="""", format=""%s"")
 |      
 |      Write array to a file as text or binary (default).
 |      
 |      Data is always written in 'C' order, independent of the order of `a`.
 |      The data produced by this method can be recovered using the function
 |      fromfile().
 |      
 |      Parameters
 |      ----------
 |      fid : file or str
 |          An open file object, or a string containing a filename.
 |      sep : str
 |          Separator between array items for text output.
 |          If """" (empty), a binary file is written, equivalent to
 |          ``file.write(a.tobytes())``.
 |      format : str
 |          Format string for text file output.
 |          Each entry in the array is formatted to text by first converting
 |          it to the closest Python type, and then using ""format"" % item.
 |      
 |      Notes
 |      -----
 |      This is a convenience function for quick storage of array data.
 |      Information on endianness and precision is lost, so this method is not a
 |      good choice for files intended to archive data or transport data between
 |      machines with different endianness. Some of these problems can be overcome
 |      by outputting the data as text files, at the expense of speed and file
 |      size.
 |  
 |  tolist(...)
 |      a.tolist()
 |      
 |      Return the array as a (possibly nested) list.
 |      
 |      Return a copy of the array data as a (nested) Python list.
 |      Data items are converted to the nearest compatible Python type.
 |      
 |      Parameters
 |      ----------
 |      none
 |      
 |      Returns
 |      -------
 |      y : list
 |          The possibly nested list of array elements.
 |      
 |      Notes
 |      -----
 |      The array may be recreated, ``a = np.array(a.tolist())``.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([1, 2])
 |      >>> a.tolist()
 |      [1, 2]
 |      >>> a = np.array([[1, 2], [3, 4]])
 |      >>> list(a)
 |      [array([1, 2]), array([3, 4])]
 |      >>> a.tolist()
 |      [[1, 2], [3, 4]]
 |  
 |  tostring(...)
 |      a.tostring(order='C')
 |      
 |      Construct Python bytes containing the raw data bytes in the array.
 |      
 |      Constructs Python bytes showing a copy of the raw contents of
 |      data memory. The bytes object can be produced in either 'C' or 'Fortran',
 |      or 'Any' order (the default is 'C'-order). 'Any' order means C-order
 |      unless the F_CONTIGUOUS flag in the array is set, in which case it
 |      means 'Fortran' order.
 |      
 |      This function is a compatibility alias for tobytes. Despite its name it returns bytes not strings.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', None}, optional
 |          Order of the data for multidimensional arrays:
 |          C, Fortran, or the same as for the original array.
 |      
 |      Returns
 |      -------
 |      s : bytes
 |          Python bytes exhibiting a copy of `a`'s raw data.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[0, 1], [2, 3]])
 |      >>> x.tobytes()
 |      b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
 |      >>> x.tobytes('C') == x.tobytes()
 |      True
 |      >>> x.tobytes('F')
 |      b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
 |  
 |  trace(...)
 |      a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)
 |      
 |      Return the sum along diagonals of the array.
 |      
 |      Refer to `numpy.trace` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.trace : equivalent function
 |  
 |  transpose(...)
 |      a.transpose(*axes)
 |      
 |      Returns a view of the array with axes transposed.
 |      
 |      For a 1-D array, this has no effect. (To change between column and
 |      row vectors, first cast the 1-D array into a matrix object.)
 |      For a 2-D array, this is the usual matrix transpose.
 |      For an n-D array, if axes are given, their order indicates how the
 |      axes are permuted (see Examples). If axes are not provided and
 |      ``a.shape = (i[0], i[1], ... i[n-2], i[n-1])``, then
 |      ``a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0])``.
 |      
 |      Parameters
 |      ----------
 |      axes : None, tuple of ints, or `n` ints
 |      
 |       * None or no argument: reverses the order of the axes.
 |      
 |       * tuple of ints: `i` in the `j`-th place in the tuple means `a`'s
 |         `i`-th axis becomes `a.transpose()`'s `j`-th axis.
 |      
 |       * `n` ints: same as an n-tuple of the same ints (this form is
 |         intended simply as a ""convenience"" alternative to the tuple form)
 |      
 |      Returns
 |      -------
 |      out : ndarray
 |          View of `a`, with axes suitably permuted.
 |      
 |      See Also
 |      --------
 |      ndarray.T : Array property returning the array transposed.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1, 2], [3, 4]])
 |      >>> a
 |      array([[1, 2],
 |             [3, 4]])
 |      >>> a.transpose()
 |      array([[1, 3],
 |             [2, 4]])
 |      >>> a.transpose((1, 0))
 |      array([[1, 3],
 |             [2, 4]])
 |      >>> a.transpose(1, 0)
 |      array([[1, 3],
 |             [2, 4]])
 |  
 |  var(...)
 |      a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False)
 |      
 |      Returns the variance of the array elements, along given axis.
 |      
 |      Refer to `numpy.var` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.var : equivalent function
 |  
 |  view(...)
 |      a.view(dtype=None, type=None)
 |      
 |      New view of array with the same data.
 |      
 |      Parameters
 |      ----------
 |      dtype : data-type or ndarray sub-class, optional
 |          Data-type descriptor of the returned view, e.g., float32 or int16. The
 |          default, None, results in the view having the same data-type as `a`.
 |          This argument can also be specified as an ndarray sub-class, which
 |          then specifies the type of the returned object (this is equivalent to
 |          setting the ``type`` parameter).
 |      type : Python type, optional
 |          Type of the returned view, e.g., ndarray or matrix.  Again, the
 |          default None results in type preservation.
 |      
 |      Notes
 |      -----
 |      ``a.view()`` is used two different ways:
 |      
 |      ``a.view(some_dtype)`` or ``a.view(dtype=some_dtype)`` constructs a view
 |      of the array's memory with a different data-type.  This can cause a
 |      reinterpretation of the bytes of memory.
 |      
 |      ``a.view(ndarray_subclass)`` or ``a.view(type=ndarray_subclass)`` just
 |      returns an instance of `ndarray_subclass` that looks at the same array
 |      (same shape, dtype, etc.)  This does not cause a reinterpretation of the
 |      memory.
 |      
 |      For ``a.view(some_dtype)``, if ``some_dtype`` has a different number of
 |      bytes per entry than the previous dtype (for example, converting a
 |      regular array to a structured array), then the behavior of the view
 |      cannot be predicted just from the superficial appearance of ``a`` (shown
 |      by ``print(a)``). It also depends on exactly how ``a`` is stored in
 |      memory. Therefore if ``a`` is C-ordered versus fortran-ordered, versus
 |      defined as a slice or transpose, etc., the view may give different
 |      results.
 |      
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])
 |      
 |      Viewing array data using a different type and dtype:
 |      
 |      >>> y = x.view(dtype=np.int16, type=np.matrix)
 |      >>> y
 |      matrix([[513]], dtype=int16)
 |      >>> print(type(y))
 |      <class 'numpy.matrixlib.defmatrix.matrix'>
 |      
 |      Creating a view on a structured array so it can be used in calculations
 |      
 |      >>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)])
 |      >>> xv = x.view(dtype=np.int8).reshape(-1,2)
 |      >>> xv
 |      array([[1, 2],
 |             [3, 4]], dtype=int8)
 |      >>> xv.mean(0)
 |      array([ 2.,  3.])
 |      
 |      Making changes to the view changes the underlying array
 |      
 |      >>> xv[0,1] = 20
 |      >>> print(x)
 |      [(1, 20) (3, 4)]
 |      
 |      Using a view to convert an array to a recarray:
 |      
 |      >>> z = x.view(np.recarray)
 |      >>> z.a
 |      array([1], dtype=int8)
 |      
 |      Views share data:
 |      
 |      >>> x[0] = (9, 10)
 |      >>> z[0]
 |      (9, 10)
 |      
 |      Views that change the dtype size (bytes per entry) should normally be
 |      avoided on arrays defined by slices, transposes, fortran-ordering, etc.:
 |      
 |      >>> x = np.array([[1,2,3],[4,5,6]], dtype=np.int16)
 |      >>> y = x[:, 0:2]
 |      >>> y
 |      array([[1, 2],
 |             [4, 5]], dtype=int16)
 |      >>> y.view(dtype=[('width', np.int16), ('length', np.int16)])
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: new type not compatible with array.
 |      >>> z = y.copy()
 |      >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
 |      array([[(1, 2)],
 |             [(4, 5)]], dtype=[('width', '<i2'), ('length', '<i2')])
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  T
 |      Same as self.transpose(), except that self is returned if
 |      self.ndim < 2.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[1.,2.],[3.,4.]])
 |      >>> x
 |      array([[ 1.,  2.],
 |             [ 3.,  4.]])
 |      >>> x.T
 |      array([[ 1.,  3.],
 |             [ 2.,  4.]])
 |      >>> x = np.array([1.,2.,3.,4.])
 |      >>> x
 |      array([ 1.,  2.,  3.,  4.])
 |      >>> x.T
 |      array([ 1.,  2.,  3.,  4.])
 |  
 |  __array_finalize__
 |      None.
 |  
 |  __array_interface__
 |      Array protocol: Python side.
 |  
 |  __array_priority__
 |      Array priority.
 |  
 |  __array_struct__
 |      Array protocol: C-struct side.
 |  
 |  base
 |      Base object if memory is from some other object.
 |      
 |      Examples
 |      --------
 |      The base of an array that owns its memory is None:
 |      
 |      >>> x = np.array([1,2,3,4])
 |      >>> x.base is None
 |      True
 |      
 |      Slicing creates a view, whose memory is shared with x:
 |      
 |      >>> y = x[2:]
 |      >>> y.base is x
 |      True
 |  
 |  ctypes
 |      An object to simplify the interaction of the array with the ctypes
 |      module.
 |      
 |      This attribute creates an object that makes it easier to use arrays
 |      when calling shared libraries with the ctypes module. The returned
 |      object has, among others, data, shape, and strides attributes (see
 |      Notes below) which themselves return ctypes objects that can be used
 |      as arguments to a shared library.
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      c : Python object
 |          Possessing attributes data, shape, strides, etc.
 |      
 |      See Also
 |      --------
 |      numpy.ctypeslib
 |      
 |      Notes
 |      -----
 |      Below are the public attributes of this object which were documented
 |      in ""Guide to NumPy"" (we have omitted undocumented public attributes,
 |      as well as documented private attributes):
 |      
 |      * data: A pointer to the memory area of the array as a Python integer.
 |        This memory area may contain data that is not aligned, or not in correct
 |        byte-order. The memory area may not even be writeable. The array
 |        flags and data-type of this array should be respected when passing this
 |        attribute to arbitrary C-code to avoid trouble that can include Python
 |        crashing. User Beware! The value of this attribute is exactly the same
 |        as self._array_interface_['data'][0].
 |      
 |      * shape (c_intp*self.ndim): A ctypes array of length self.ndim where
 |        the basetype is the C-integer corresponding to dtype('p') on this
 |        platform. This base-type could be c_int, c_long, or c_longlong
 |        depending on the platform. The c_intp type is defined accordingly in
 |        numpy.ctypeslib. The ctypes array contains the shape of the underlying
 |        array.
 |      
 |      * strides (c_intp*self.ndim): A ctypes array of length self.ndim where
 |        the basetype is the same as for the shape attribute. This ctypes array
 |        contains the strides information from the underlying array. This strides
 |        information is important for showing how many bytes must be jumped to
 |        get to the next element in the array.
 |      
 |      * data_as(obj): Return the data pointer cast to a particular c-types object.
 |        For example, calling self._as_parameter_ is equivalent to
 |        self.data_as(ctypes.c_void_p). Perhaps you want to use the data as a
 |        pointer to a ctypes array of floating-point data:
 |        self.data_as(ctypes.POINTER(ctypes.c_double)).
 |      
 |      * shape_as(obj): Return the shape tuple as an array of some other c-types
 |        type. For example: self.shape_as(ctypes.c_short).
 |      
 |      * strides_as(obj): Return the strides tuple as an array of some other
 |        c-types type. For example: self.strides_as(ctypes.c_longlong).
 |      
 |      Be careful using the ctypes attribute - especially on temporary
 |      arrays or arrays constructed on the fly. For example, calling
 |      ``(a+b).ctypes.data_as(ctypes.c_void_p)`` returns a pointer to memory
 |      that is invalid because the array created as (a+b) is deallocated
 |      before the next Python statement. You can avoid this problem using
 |      either ``c=a+b`` or ``ct=(a+b).ctypes``. In the latter case, ct will
 |      hold a reference to the array until ct is deleted or re-assigned.
 |      
 |      If the ctypes module is not available, then the ctypes attribute
 |      of array objects still returns something useful, but ctypes objects
 |      are not returned and errors may be raised instead. In particular,
 |      the object will still have the as parameter attribute which will
 |      return an integer equal to the data attribute.
 |      
 |      Examples
 |      --------
 |      >>> import ctypes
 |      >>> x
 |      array([[0, 1],
 |             [2, 3]])
 |      >>> x.ctypes.data
 |      30439712
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long))
 |      <ctypes.LP_c_long object at 0x01F01300>
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)).contents
 |      c_long(0)
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_longlong)).contents
 |      c_longlong(4294967296L)
 |      >>> x.ctypes.shape
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FFD580>
 |      >>> x.ctypes.shape_as(ctypes.c_long)
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
 |      >>> x.ctypes.strides
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
 |      >>> x.ctypes.strides_as(ctypes.c_longlong)
 |      <numpy.core._internal.c_longlong_Array_2 object at 0x01F01300>
 |  
 |  data
 |      Python buffer object pointing to the start of the array's data.
 |  
 |  dtype
 |      Data-type of the array's elements.
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      d : numpy dtype object
 |      
 |      See Also
 |      --------
 |      numpy.dtype
 |      
 |      Examples
 |      --------
 |      >>> x
 |      array([[0, 1],
 |             [2, 3]])
 |      >>> x.dtype
 |      dtype('int32')
 |      >>> type(x.dtype)
 |      <type 'numpy.dtype'>
 |  
 |  flags
 |      Information about the memory layout of the array.
 |      
 |      Attributes
 |      ----------
 |      C_CONTIGUOUS (C)
 |          The data is in a single, C-style contiguous segment.
 |      F_CONTIGUOUS (F)
 |          The data is in a single, Fortran-style contiguous segment.
 |      OWNDATA (O)
 |          The array owns the memory it uses or borrows it from another object.
 |      WRITEABLE (W)
 |          The data area can be written to.  Setting this to False locks
 |          the data, making it read-only.  A view (slice, etc.) inherits WRITEABLE
 |          from its base array at creation time, but a view of a writeable
 |          array may be subsequently locked while the base array remains writeable.
 |          (The opposite is not true, in that a view of a locked array may not
 |          be made writeable.  However, currently, locking a base object does not
 |          lock any views that already reference it, so under that circumstance it
 |          is possible to alter the contents of a locked array via a previously
 |          created writeable view onto it.)  Attempting to change a non-writeable
 |          array raises a RuntimeError exception.
 |      ALIGNED (A)
 |          The data and all elements are aligned appropriately for the hardware.
 |      WRITEBACKIFCOPY (X)
 |          This array is a copy of some other array. The C-API function
 |          PyArray_ResolveWritebackIfCopy must be called before deallocating
 |          to the base array will be updated with the contents of this array.
 |      UPDATEIFCOPY (U)
 |          (Deprecated, use WRITEBACKIFCOPY) This array is a copy of some other array.
 |          When this array is
 |          deallocated, the base array will be updated with the contents of
 |          this array.
 |      FNC
 |          F_CONTIGUOUS and not C_CONTIGUOUS.
 |      FORC
 |          F_CONTIGUOUS or C_CONTIGUOUS (one-segment test).
 |      BEHAVED (B)
 |          ALIGNED and WRITEABLE.
 |      CARRAY (CA)
 |          BEHAVED and C_CONTIGUOUS.
 |      FARRAY (FA)
 |          BEHAVED and F_CONTIGUOUS and not C_CONTIGUOUS.
 |      
 |      Notes
 |      -----
 |      The `flags` object can be accessed dictionary-like (as in ``a.flags['WRITEABLE']``),
 |      or by using lowercased attribute names (as in ``a.flags.writeable``). Short flag
 |      names are only supported in dictionary access.
 |      
 |      Only the WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED flags can be
 |      changed by the user, via direct assignment to the attribute or dictionary
 |      entry, or by calling `ndarray.setflags`.
 |      
 |      The array flags cannot be set arbitrarily:
 |      
 |      - UPDATEIFCOPY can only be set ``False``.
 |      - WRITEBACKIFCOPY can only be set ``False``.
 |      - ALIGNED can only be set ``True`` if the data is truly aligned.
 |      - WRITEABLE can only be set ``True`` if the array owns its own memory
 |        or the ultimate owner of the memory exposes a writeable buffer
 |        interface or is a string.
 |      
 |      Arrays can be both C-style and Fortran-style contiguous simultaneously.
 |      This is clear for 1-dimensional arrays, but can also be true for higher
 |      dimensional arrays.
 |      
 |      Even for contiguous arrays a stride for a given dimension
 |      ``arr.strides[dim]`` may be *arbitrary* if ``arr.shape[dim] == 1``
 |      or the array has no elements.
 |      It does *not* generally hold that ``self.strides[-1] == self.itemsize``
 |      for C-style contiguous arrays or ``self.strides[0] == self.itemsize`` for
 |      Fortran-style contiguous arrays is true.
 |  
 |  flat
 |      A 1-D iterator over the array.
 |      
 |      This is a `numpy.flatiter` instance, which acts similarly to, but is not
 |      a subclass of, Python's built-in iterator object.
 |      
 |      See Also
 |      --------
 |      flatten : Return a copy of the array collapsed into one dimension.
 |      
 |      flatiter
 |      
 |      Examples
 |      --------
 |      >>> x = np.arange(1, 7).reshape(2, 3)
 |      >>> x
 |      array([[1, 2, 3],
 |             [4, 5, 6]])
 |      >>> x.flat[3]
 |      4
 |      >>> x.T
 |      array([[1, 4],
 |             [2, 5],
 |             [3, 6]])
 |      >>> x.T.flat[3]
 |      5
 |      >>> type(x.flat)
 |      <type 'numpy.flatiter'>
 |      
 |      An assignment example:
 |      
 |      >>> x.flat = 3; x
 |      array([[3, 3, 3],
 |             [3, 3, 3]])
 |      >>> x.flat[[1,4]] = 1; x
 |      array([[3, 1, 3],
 |             [3, 1, 3]])
 |  
 |  imag
 |      The imaginary part of the array.
 |      
 |      Examples
 |      --------
 |      >>> x = np.sqrt([1+0j, 0+1j])
 |      >>> x.imag
 |      array([ 0.        ,  0.70710678])
 |      >>> x.imag.dtype
 |      dtype('float64')
 |  
 |  itemsize
 |      Length of one array element in bytes.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1,2,3], dtype=np.float64)
 |      >>> x.itemsize
 |      8
 |      >>> x = np.array([1,2,3], dtype=np.complex128)
 |      >>> x.itemsize
 |      16
 |  
 |  nbytes
 |      Total bytes consumed by the elements of the array.
 |      
 |      Notes
 |      -----
 |      Does not include memory consumed by non-element attributes of the
 |      array object.
 |      
 |      Examples
 |      --------
 |      >>> x = np.zeros((3,5,2), dtype=np.complex128)
 |      >>> x.nbytes
 |      480
 |      >>> np.prod(x.shape) * x.itemsize
 |      480
 |  
 |  ndim
 |      Number of array dimensions.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 3])
 |      >>> x.ndim
 |      1
 |      >>> y = np.zeros((2, 3, 4))
 |      >>> y.ndim
 |      3
 |  
 |  real
 |      The real part of the array.
 |      
 |      Examples
 |      --------
 |      >>> x = np.sqrt([1+0j, 0+1j])
 |      >>> x.real
 |      array([ 1.        ,  0.70710678])
 |      >>> x.real.dtype
 |      dtype('float64')
 |      
 |      See Also
 |      --------
 |      numpy.real : equivalent function
 |  
 |  shape
 |      Tuple of array dimensions.
 |      
 |      The shape property is usually used to get the current shape of an array,
 |      but may also be used to reshape the array in-place by assigning a tuple of
 |      array dimensions to it.  As with `numpy.reshape`, one of the new shape
 |      dimensions can be -1, in which case its value is inferred from the size of
 |      the array and the remaining dimensions. Reshaping an array in-place will
 |      fail if a copy is required.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 3, 4])
 |      >>> x.shape
 |      (4,)
 |      >>> y = np.zeros((2, 3, 4))
 |      >>> y.shape
 |      (2, 3, 4)
 |      >>> y.shape = (3, 8)
 |      >>> y
 |      array([[ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
 |             [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
 |             [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.]])
 |      >>> y.shape = (3, 6)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: total size of new array must be unchanged
 |      >>> np.zeros((4,2))[::2].shape = (-1,)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      AttributeError: incompatible shape for a non-contiguous array
 |      
 |      See Also
 |      --------
 |      numpy.reshape : similar function
 |      ndarray.reshape : similar method
 |  
 |  size
 |      Number of elements in the array.
 |      
 |      Equivalent to ``np.prod(a.shape)``, i.e., the product of the array's
 |      dimensions.
 |      
 |      Examples
 |      --------
 |      >>> x = np.zeros((3, 5, 2), dtype=np.complex128)
 |      >>> x.size
 |      30
 |      >>> np.prod(x.shape)
 |      30
 |  
 |  strides
 |      Tuple of bytes to step in each dimension when traversing an array.
 |      
 |      The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a`
 |      is::
 |      
 |          offset = sum(np.array(i) * a.strides)
 |      
 |      A more detailed explanation of strides can be found in the
 |      ""ndarray.rst"" file in the NumPy reference guide.
 |      
 |      Notes
 |      -----
 |      Imagine an array of 32-bit integers (each 4 bytes)::
 |      
 |        x = np.array([[0, 1, 2, 3, 4],
 |                      [5, 6, 7, 8, 9]], dtype=np.int32)
 |      
 |      This array is stored in memory as 40 bytes, one after the other
 |      (known as a contiguous block of memory).  The strides of an array tell
 |      us how many bytes we have to skip in memory to move to the next position
 |      along a certain axis.  For example, we have to skip 4 bytes (1 value) to
 |      move to the next column, but 20 bytes (5 values) to get to the same
 |      position in the next row.  As such, the strides for the array `x` will be
 |      ``(20, 4)``.
 |      
 |      See Also
 |      --------
 |      numpy.lib.stride_tricks.as_strided
 |      
 |      Examples
 |      --------
 |      >>> y = np.reshape(np.arange(2*3*4), (2,3,4))
 |      >>> y
 |      array([[[ 0,  1,  2,  3],
 |              [ 4,  5,  6,  7],
 |              [ 8,  9, 10, 11]],
 |             [[12, 13, 14, 15],
 |              [16, 17, 18, 19],
 |              [20, 21, 22, 23]]])
 |      >>> y.strides
 |      (48, 16, 4)
 |      >>> y[1,1,1]
 |      17
 |      >>> offset=sum(y.strides * np.array((1,1,1)))
 |      >>> offset/y.itemsize
 |      17
 |      
 |      >>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0)
 |      >>> x.strides
 |      (32, 4, 224, 1344)
 |      >>> i = np.array([3,5,2,2])
 |      >>> offset = sum(i * x.strides)
 |      >>> x[3,5,2,2]
 |      813
 |      >>> offset / x.itemsize
 |      813
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.mmio.ndarray,io.mmio,ndarray,"Python Library Documentation: class ndarray in module numpy

class ndarray(builtins.object)
 |  ndarray(shape, dtype=float, buffer=None, offset=0,
 |          strides=None, order=None)
 |  
 |  An array object represents a multidimensional, homogeneous array
 |  of fixed-size items.  An associated data-type object describes the
 |  format of each element in the array (its byte-order, how many bytes it
 |  occupies in memory, whether it is an integer, a floating point number,
 |  or something else, etc.)
 |  
 |  Arrays should be constructed using `array`, `zeros` or `empty` (refer
 |  to the See Also section below).  The parameters given here refer to
 |  a low-level method (`ndarray(...)`) for instantiating an array.
 |  
 |  For more information, refer to the `numpy` module and examine the
 |  methods and attributes of an array.
 |  
 |  Parameters
 |  ----------
 |  (for the __new__ method; see Notes below)
 |  
 |  shape : tuple of ints
 |      Shape of created array.
 |  dtype : data-type, optional
 |      Any object that can be interpreted as a numpy data type.
 |  buffer : object exposing buffer interface, optional
 |      Used to fill the array with data.
 |  offset : int, optional
 |      Offset of array data in buffer.
 |  strides : tuple of ints, optional
 |      Strides of data in memory.
 |  order : {'C', 'F'}, optional
 |      Row-major (C-style) or column-major (Fortran-style) order.
 |  
 |  Attributes
 |  ----------
 |  T : ndarray
 |      Transpose of the array.
 |  data : buffer
 |      The array's elements, in memory.
 |  dtype : dtype object
 |      Describes the format of the elements in the array.
 |  flags : dict
 |      Dictionary containing information related to memory use, e.g.,
 |      'C_CONTIGUOUS', 'OWNDATA', 'WRITEABLE', etc.
 |  flat : numpy.flatiter object
 |      Flattened version of the array as an iterator.  The iterator
 |      allows assignments, e.g., ``x.flat = 3`` (See `ndarray.flat` for
 |      assignment examples; TODO).
 |  imag : ndarray
 |      Imaginary part of the array.
 |  real : ndarray
 |      Real part of the array.
 |  size : int
 |      Number of elements in the array.
 |  itemsize : int
 |      The memory use of each array element in bytes.
 |  nbytes : int
 |      The total number of bytes required to store the array data,
 |      i.e., ``itemsize * size``.
 |  ndim : int
 |      The array's number of dimensions.
 |  shape : tuple of ints
 |      Shape of the array.
 |  strides : tuple of ints
 |      The step-size required to move from one element to the next in
 |      memory. For example, a contiguous ``(3, 4)`` array of type
 |      ``int16`` in C-order has strides ``(8, 2)``.  This implies that
 |      to move from element to element in memory requires jumps of 2 bytes.
 |      To move from row-to-row, one needs to jump 8 bytes at a time
 |      (``2 * 4``).
 |  ctypes : ctypes object
 |      Class containing properties of the array needed for interaction
 |      with ctypes.
 |  base : ndarray
 |      If the array is a view into another array, that array is its `base`
 |      (unless that array is also a view).  The `base` array is where the
 |      array data is actually stored.
 |  
 |  See Also
 |  --------
 |  array : Construct an array.
 |  zeros : Create an array, each element of which is zero.
 |  empty : Create an array, but leave its allocated memory unchanged (i.e.,
 |          it contains ""garbage"").
 |  dtype : Create a data-type.
 |  
 |  Notes
 |  -----
 |  There are two modes of creating an array using ``__new__``:
 |  
 |  1. If `buffer` is None, then only `shape`, `dtype`, and `order`
 |     are used.
 |  2. If `buffer` is an object exposing the buffer interface, then
 |     all keywords are interpreted.
 |  
 |  No ``__init__`` method is needed because the array is fully initialized
 |  after the ``__new__`` method.
 |  
 |  Examples
 |  --------
 |  These examples illustrate the low-level `ndarray` constructor.  Refer
 |  to the `See Also` section above for easier ways of constructing an
 |  ndarray.
 |  
 |  First mode, `buffer` is None:
 |  
 |  >>> np.ndarray(shape=(2,2), dtype=float, order='F')
 |  array([[ -1.13698227e+002,   4.25087011e-303],
 |         [  2.88528414e-306,   3.27025015e-309]])         #random
 |  
 |  Second mode:
 |  
 |  >>> np.ndarray((2,), buffer=np.array([1,2,3]),
 |  ...            offset=np.int_().itemsize,
 |  ...            dtype=int) # offset = 1*itemsize, i.e. skip first element
 |  array([2, 3])
 |  
 |  Methods defined here:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __array__(...)
 |      a.__array__(|dtype) -> reference if type unchanged, copy otherwise.
 |      
 |      Returns either a new reference to self if dtype is not given or a new array
 |      of provided data type if dtype is different from the current dtype of the
 |      array.
 |  
 |  __array_prepare__(...)
 |      a.__array_prepare__(obj) -> Object of same type as ndarray object obj.
 |  
 |  __array_ufunc__(...)
 |  
 |  __array_wrap__(...)
 |      a.__array_wrap__(obj) -> Object of same type as ndarray object a.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __complex__(...)
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __copy__(...)
 |      a.__copy__()
 |      
 |      Used if :func:`copy.copy` is called on an array. Returns a copy of the array.
 |      
 |      Equivalent to ``a.copy(order='K')``.
 |  
 |  __deepcopy__(...)
 |      a.__deepcopy__(memo, /) -> Deep copy of array.
 |      
 |      Used if :func:`copy.deepcopy` is called on an array.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __format__(...)
 |      default object formatter
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iadd__(self, value, /)
 |      Return self+=value.
 |  
 |  __iand__(self, value, /)
 |      Return self&=value.
 |  
 |  __ifloordiv__(self, value, /)
 |      Return self//=value.
 |  
 |  __ilshift__(self, value, /)
 |      Return self<<=value.
 |  
 |  __imatmul__(self, value, /)
 |      Return self@=value.
 |  
 |  __imod__(self, value, /)
 |      Return self%=value.
 |  
 |  __imul__(self, value, /)
 |      Return self*=value.
 |  
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __ior__(self, value, /)
 |      Return self|=value.
 |  
 |  __ipow__(self, value, /)
 |      Return self**=value.
 |  
 |  __irshift__(self, value, /)
 |      Return self>>=value.
 |  
 |  __isub__(self, value, /)
 |      Return self-=value.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __itruediv__(self, value, /)
 |      Return self/=value.
 |  
 |  __ixor__(self, value, /)
 |      Return self^=value.
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __matmul__(self, value, /)
 |      Return self@value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __reduce__(...)
 |      a.__reduce__()
 |      
 |      For pickling.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmatmul__(self, value, /)
 |      Return value@self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __setstate__(...)
 |      a.__setstate__(state, /)
 |      
 |      For unpickling.
 |      
 |      The `state` argument must be a sequence that contains the following
 |      elements:
 |      
 |      Parameters
 |      ----------
 |      version : int
 |          optional pickle version. If omitted defaults to 0.
 |      shape : tuple
 |      dtype : data-type
 |      isFortran : bool
 |      rawdata : string or list
 |          a binary string with the data (or a list if 'a' is an object array)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  all(...)
 |      a.all(axis=None, out=None, keepdims=False)
 |      
 |      Returns True if all elements evaluate to True.
 |      
 |      Refer to `numpy.all` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.all : equivalent function
 |  
 |  any(...)
 |      a.any(axis=None, out=None, keepdims=False)
 |      
 |      Returns True if any of the elements of `a` evaluate to True.
 |      
 |      Refer to `numpy.any` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.any : equivalent function
 |  
 |  argmax(...)
 |      a.argmax(axis=None, out=None)
 |      
 |      Return indices of the maximum values along the given axis.
 |      
 |      Refer to `numpy.argmax` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argmax : equivalent function
 |  
 |  argmin(...)
 |      a.argmin(axis=None, out=None)
 |      
 |      Return indices of the minimum values along the given axis of `a`.
 |      
 |      Refer to `numpy.argmin` for detailed documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argmin : equivalent function
 |  
 |  argpartition(...)
 |      a.argpartition(kth, axis=-1, kind='introselect', order=None)
 |      
 |      Returns the indices that would partition this array.
 |      
 |      Refer to `numpy.argpartition` for full documentation.
 |      
 |      .. versionadded:: 1.8.0
 |      
 |      See Also
 |      --------
 |      numpy.argpartition : equivalent function
 |  
 |  argsort(...)
 |      a.argsort(axis=-1, kind='quicksort', order=None)
 |      
 |      Returns the indices that would sort this array.
 |      
 |      Refer to `numpy.argsort` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argsort : equivalent function
 |  
 |  astype(...)
 |      a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)
 |      
 |      Copy of the array, cast to a specified type.
 |      
 |      Parameters
 |      ----------
 |      dtype : str or dtype
 |          Typecode or data-type to which the array is cast.
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          Controls the memory layout order of the result.
 |          'C' means C order, 'F' means Fortran order, 'A'
 |          means 'F' order if all the arrays are Fortran contiguous,
 |          'C' order otherwise, and 'K' means as close to the
 |          order the array elements appear in memory as possible.
 |          Default is 'K'.
 |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
 |          Controls what kind of data casting may occur. Defaults to 'unsafe'
 |          for backwards compatibility.
 |      
 |            * 'no' means the data types should not be cast at all.
 |            * 'equiv' means only byte-order changes are allowed.
 |            * 'safe' means only casts which can preserve values are allowed.
 |            * 'same_kind' means only safe casts or casts within a kind,
 |              like float64 to float32, are allowed.
 |            * 'unsafe' means any data conversions may be done.
 |      subok : bool, optional
 |          If True, then sub-classes will be passed-through (default), otherwise
 |          the returned array will be forced to be a base-class array.
 |      copy : bool, optional
 |          By default, astype always returns a newly allocated array. If this
 |          is set to false, and the `dtype`, `order`, and `subok`
 |          requirements are satisfied, the input array is returned instead
 |          of a copy.
 |      
 |      Returns
 |      -------
 |      arr_t : ndarray
 |          Unless `copy` is False and the other conditions for returning the input
 |          array are satisfied (see description for `copy` input parameter), `arr_t`
 |          is a new array of the same shape as the input array, with dtype, order
 |          given by `dtype`, `order`.
 |      
 |      Notes
 |      -----
 |      Starting in NumPy 1.9, astype method now returns an error if the string
 |      dtype to cast to is not long enough in 'safe' casting mode to hold the max
 |      value of integer/float array that is being casted. Previously the casting
 |      was allowed even if the result was truncated.
 |      
 |      Raises
 |      ------
 |      ComplexWarning
 |          When casting from complex to float or int. To avoid this,
 |          one should use ``a.real.astype(t)``.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 2.5])
 |      >>> x
 |      array([ 1. ,  2. ,  2.5])
 |      
 |      >>> x.astype(int)
 |      array([1, 2, 2])
 |  
 |  byteswap(...)
 |      a.byteswap(inplace=False)
 |      
 |      Swap the bytes of the array elements
 |      
 |      Toggle between low-endian and big-endian data representation by
 |      returning a byteswapped array, optionally swapped in-place.
 |      
 |      Parameters
 |      ----------
 |      inplace : bool, optional
 |          If ``True``, swap bytes in-place, default is ``False``.
 |      
 |      Returns
 |      -------
 |      out : ndarray
 |          The byteswapped array. If `inplace` is ``True``, this is
 |          a view to self.
 |      
 |      Examples
 |      --------
 |      >>> A = np.array([1, 256, 8755], dtype=np.int16)
 |      >>> map(hex, A)
 |      ['0x1', '0x100', '0x2233']
 |      >>> A.byteswap(inplace=True)
 |      array([  256,     1, 13090], dtype=int16)
 |      >>> map(hex, A)
 |      ['0x100', '0x1', '0x3322']
 |      
 |      Arrays of strings are not swapped
 |      
 |      >>> A = np.array(['ceg', 'fac'])
 |      >>> A.byteswap()
 |      array(['ceg', 'fac'],
 |            dtype='|S3')
 |  
 |  choose(...)
 |      a.choose(choices, out=None, mode='raise')
 |      
 |      Use an index array to construct a new array from a set of choices.
 |      
 |      Refer to `numpy.choose` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.choose : equivalent function
 |  
 |  clip(...)
 |      a.clip(min=None, max=None, out=None)
 |      
 |      Return an array whose values are limited to ``[min, max]``.
 |      One of max or min must be given.
 |      
 |      Refer to `numpy.clip` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.clip : equivalent function
 |  
 |  compress(...)
 |      a.compress(condition, axis=None, out=None)
 |      
 |      Return selected slices of this array along given axis.
 |      
 |      Refer to `numpy.compress` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.compress : equivalent function
 |  
 |  conj(...)
 |      a.conj()
 |      
 |      Complex-conjugate all elements.
 |      
 |      Refer to `numpy.conjugate` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.conjugate : equivalent function
 |  
 |  conjugate(...)
 |      a.conjugate()
 |      
 |      Return the complex conjugate, element-wise.
 |      
 |      Refer to `numpy.conjugate` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.conjugate : equivalent function
 |  
 |  copy(...)
 |      a.copy(order='C')
 |      
 |      Return a copy of the array.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          Controls the memory layout of the copy. 'C' means C-order,
 |          'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
 |          'C' otherwise. 'K' means match the layout of `a` as closely
 |          as possible. (Note that this function and :func:`numpy.copy` are very
 |          similar, but have different default values for their order=
 |          arguments.)
 |      
 |      See also
 |      --------
 |      numpy.copy
 |      numpy.copyto
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[1,2,3],[4,5,6]], order='F')
 |      
 |      >>> y = x.copy()
 |      
 |      >>> x.fill(0)
 |      
 |      >>> x
 |      array([[0, 0, 0],
 |             [0, 0, 0]])
 |      
 |      >>> y
 |      array([[1, 2, 3],
 |             [4, 5, 6]])
 |      
 |      >>> y.flags['C_CONTIGUOUS']
 |      True
 |  
 |  cumprod(...)
 |      a.cumprod(axis=None, dtype=None, out=None)
 |      
 |      Return the cumulative product of the elements along the given axis.
 |      
 |      Refer to `numpy.cumprod` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.cumprod : equivalent function
 |  
 |  cumsum(...)
 |      a.cumsum(axis=None, dtype=None, out=None)
 |      
 |      Return the cumulative sum of the elements along the given axis.
 |      
 |      Refer to `numpy.cumsum` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.cumsum : equivalent function
 |  
 |  diagonal(...)
 |      a.diagonal(offset=0, axis1=0, axis2=1)
 |      
 |      Return specified diagonals. In NumPy 1.9 the returned array is a
 |      read-only view instead of a copy as in previous NumPy versions.  In
 |      a future version the read-only restriction will be removed.
 |      
 |      Refer to :func:`numpy.diagonal` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.diagonal : equivalent function
 |  
 |  dot(...)
 |      a.dot(b, out=None)
 |      
 |      Dot product of two arrays.
 |      
 |      Refer to `numpy.dot` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.dot : equivalent function
 |      
 |      Examples
 |      --------
 |      >>> a = np.eye(2)
 |      >>> b = np.ones((2, 2)) * 2
 |      >>> a.dot(b)
 |      array([[ 2.,  2.],
 |             [ 2.,  2.]])
 |      
 |      This array method can be conveniently chained:
 |      
 |      >>> a.dot(b).dot(b)
 |      array([[ 8.,  8.],
 |             [ 8.,  8.]])
 |  
 |  dump(...)
 |      a.dump(file)
 |      
 |      Dump a pickle of the array to the specified file.
 |      The array can be read back with pickle.load or numpy.load.
 |      
 |      Parameters
 |      ----------
 |      file : str
 |          A string naming the dump file.
 |  
 |  dumps(...)
 |      a.dumps()
 |      
 |      Returns the pickle of the array as a string.
 |      pickle.loads or numpy.loads will convert the string back to an array.
 |      
 |      Parameters
 |      ----------
 |      None
 |  
 |  fill(...)
 |      a.fill(value)
 |      
 |      Fill the array with a scalar value.
 |      
 |      Parameters
 |      ----------
 |      value : scalar
 |          All elements of `a` will be assigned this value.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([1, 2])
 |      >>> a.fill(0)
 |      >>> a
 |      array([0, 0])
 |      >>> a = np.empty(2)
 |      >>> a.fill(1)
 |      >>> a
 |      array([ 1.,  1.])
 |  
 |  flatten(...)
 |      a.flatten(order='C')
 |      
 |      Return a copy of the array collapsed into one dimension.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          'C' means to flatten in row-major (C-style) order.
 |          'F' means to flatten in column-major (Fortran-
 |          style) order. 'A' means to flatten in column-major
 |          order if `a` is Fortran *contiguous* in memory,
 |          row-major order otherwise. 'K' means to flatten
 |          `a` in the order the elements occur in memory.
 |          The default is 'C'.
 |      
 |      Returns
 |      -------
 |      y : ndarray
 |          A copy of the input array, flattened to one dimension.
 |      
 |      See Also
 |      --------
 |      ravel : Return a flattened array.
 |      flat : A 1-D flat iterator over the array.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1,2], [3,4]])
 |      >>> a.flatten()
 |      array([1, 2, 3, 4])
 |      >>> a.flatten('F')
 |      array([1, 3, 2, 4])
 |  
 |  getfield(...)
 |      a.getfield(dtype, offset=0)
 |      
 |      Returns a field of the given array as a certain type.
 |      
 |      A field is a view of the array data with a given data-type. The values in
 |      the view are determined by the given type and the offset into the current
 |      array in bytes. The offset needs to be such that the view dtype fits in the
 |      array dtype; for example an array of dtype complex128 has 16-byte elements.
 |      If taking a view with a 32-bit integer (4 bytes), the offset needs to be
 |      between 0 and 12 bytes.
 |      
 |      Parameters
 |      ----------
 |      dtype : str or dtype
 |          The data type of the view. The dtype size of the view can not be larger
 |          than that of the array itself.
 |      offset : int
 |          Number of bytes to skip before beginning the element view.
 |      
 |      Examples
 |      --------
 |      >>> x = np.diag([1.+1.j]*2)
 |      >>> x[1, 1] = 2 + 4.j
 |      >>> x
 |      array([[ 1.+1.j,  0.+0.j],
 |             [ 0.+0.j,  2.+4.j]])
 |      >>> x.getfield(np.float64)
 |      array([[ 1.,  0.],
 |             [ 0.,  2.]])
 |      
 |      By choosing an offset of 8 bytes we can select the complex part of the
 |      array for our view:
 |      
 |      >>> x.getfield(np.float64, offset=8)
 |      array([[ 1.,  0.],
 |         [ 0.,  4.]])
 |  
 |  item(...)
 |      a.item(*args)
 |      
 |      Copy an element of an array to a standard Python scalar and return it.
 |      
 |      Parameters
 |      ----------
 |      \*args : Arguments (variable number and type)
 |      
 |          * none: in this case, the method only works for arrays
 |            with one element (`a.size == 1`), which element is
 |            copied into a standard Python scalar object and returned.
 |      
 |          * int_type: this argument is interpreted as a flat index into
 |            the array, specifying which element to copy and return.
 |      
 |          * tuple of int_types: functions as does a single int_type argument,
 |            except that the argument is interpreted as an nd-index into the
 |            array.
 |      
 |      Returns
 |      -------
 |      z : Standard Python scalar object
 |          A copy of the specified element of the array as a suitable
 |          Python scalar
 |      
 |      Notes
 |      -----
 |      When the data type of `a` is longdouble or clongdouble, item() returns
 |      a scalar array object because there is no available Python scalar that
 |      would not lose information. Void arrays return a buffer object for item(),
 |      unless fields are defined, in which case a tuple is returned.
 |      
 |      `item` is very similar to a[args], except, instead of an array scalar,
 |      a standard Python scalar is returned. This can be useful for speeding up
 |      access to elements of the array and doing arithmetic on elements of the
 |      array using Python's optimized math.
 |      
 |      Examples
 |      --------
 |      >>> x = np.random.randint(9, size=(3, 3))
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 8, 3],
 |             [8, 5, 3]])
 |      >>> x.item(3)
 |      2
 |      >>> x.item(7)
 |      5
 |      >>> x.item((0, 1))
 |      1
 |      >>> x.item((2, 2))
 |      3
 |  
 |  itemset(...)
 |      a.itemset(*args)
 |      
 |      Insert scalar into an array (scalar is cast to array's dtype, if possible)
 |      
 |      There must be at least 1 argument, and define the last argument
 |      as *item*.  Then, ``a.itemset(*args)`` is equivalent to but faster
 |      than ``a[args] = item``.  The item should be a scalar value and `args`
 |      must select a single item in the array `a`.
 |      
 |      Parameters
 |      ----------
 |      \*args : Arguments
 |          If one argument: a scalar, only used in case `a` is of size 1.
 |          If two arguments: the last argument is the value to be set
 |          and must be a scalar, the first argument specifies a single array
 |          element location. It is either an int or a tuple.
 |      
 |      Notes
 |      -----
 |      Compared to indexing syntax, `itemset` provides some speed increase
 |      for placing a scalar into a particular location in an `ndarray`,
 |      if you must do this.  However, generally this is discouraged:
 |      among other problems, it complicates the appearance of the code.
 |      Also, when using `itemset` (and `item`) inside a loop, be sure
 |      to assign the methods to a local variable to avoid the attribute
 |      look-up at each loop iteration.
 |      
 |      Examples
 |      --------
 |      >>> x = np.random.randint(9, size=(3, 3))
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 8, 3],
 |             [8, 5, 3]])
 |      >>> x.itemset(4, 0)
 |      >>> x.itemset((2, 2), 9)
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 0, 3],
 |             [8, 5, 9]])
 |  
 |  max(...)
 |      a.max(axis=None, out=None, keepdims=False)
 |      
 |      Return the maximum along a given axis.
 |      
 |      Refer to `numpy.amax` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.amax : equivalent function
 |  
 |  mean(...)
 |      a.mean(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Returns the average of the array elements along given axis.
 |      
 |      Refer to `numpy.mean` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.mean : equivalent function
 |  
 |  min(...)
 |      a.min(axis=None, out=None, keepdims=False)
 |      
 |      Return the minimum along a given axis.
 |      
 |      Refer to `numpy.amin` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.amin : equivalent function
 |  
 |  newbyteorder(...)
 |      arr.newbyteorder(new_order='S')
 |      
 |      Return the array with the same data viewed with a different byte order.
 |      
 |      Equivalent to::
 |      
 |          arr.view(arr.dtype.newbytorder(new_order))
 |      
 |      Changes are also made in all fields and sub-arrays of the array data
 |      type.
 |      
 |      
 |      
 |      Parameters
 |      ----------
 |      new_order : string, optional
 |          Byte order to force; a value from the byte order specifications
 |          below. `new_order` codes can be any of:
 |      
 |          * 'S' - swap dtype from current to opposite endian
 |          * {'<', 'L'} - little endian
 |          * {'>', 'B'} - big endian
 |          * {'=', 'N'} - native order
 |          * {'|', 'I'} - ignore (no change to byte order)
 |      
 |          The default value ('S') results in swapping the current
 |          byte order. The code does a case-insensitive check on the first
 |          letter of `new_order` for the alternatives above.  For example,
 |          any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 |      
 |      
 |      Returns
 |      -------
 |      new_arr : array
 |          New array object with the dtype reflecting given change to the
 |          byte order.
 |  
 |  nonzero(...)
 |      a.nonzero()
 |      
 |      Return the indices of the elements that are non-zero.
 |      
 |      Refer to `numpy.nonzero` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.nonzero : equivalent function
 |  
 |  partition(...)
 |      a.partition(kth, axis=-1, kind='introselect', order=None)
 |      
 |      Rearranges the elements in the array in such a way that value of the
 |      element in kth position is in the position it would be in a sorted array.
 |      All elements smaller than the kth element are moved before this element and
 |      all equal or greater are moved behind it. The ordering of the elements in
 |      the two partitions is undefined.
 |      
 |      .. versionadded:: 1.8.0
 |      
 |      Parameters
 |      ----------
 |      kth : int or sequence of ints
 |          Element index to partition by. The kth element value will be in its
 |          final sorted position and all smaller elements will be moved before it
 |          and all equal or greater elements behind it.
 |          The order all elements in the partitions is undefined.
 |          If provided with a sequence of kth it will partition all elements
 |          indexed by kth of them into their sorted position at once.
 |      axis : int, optional
 |          Axis along which to sort. Default is -1, which means sort along the
 |          last axis.
 |      kind : {'introselect'}, optional
 |          Selection algorithm. Default is 'introselect'.
 |      order : str or list of str, optional
 |          When `a` is an array with fields defined, this argument specifies
 |          which fields to compare first, second, etc.  A single field can
 |          be specified as a string, and not all fields need be specified,
 |          but unspecified fields will still be used, in the order in which
 |          they come up in the dtype, to break ties.
 |      
 |      See Also
 |      --------
 |      numpy.partition : Return a parititioned copy of an array.
 |      argpartition : Indirect partition.
 |      sort : Full sort.
 |      
 |      Notes
 |      -----
 |      See ``np.partition`` for notes on the different algorithms.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([3, 4, 2, 1])
 |      >>> a.partition(3)
 |      >>> a
 |      array([2, 1, 3, 4])
 |      
 |      >>> a.partition((1, 3))
 |      array([1, 2, 3, 4])
 |  
 |  prod(...)
 |      a.prod(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Return the product of the array elements over the given axis
 |      
 |      Refer to `numpy.prod` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.prod : equivalent function
 |  
 |  ptp(...)
 |      a.ptp(axis=None, out=None)
 |      
 |      Peak to peak (maximum - minimum) value along a given axis.
 |      
 |      Refer to `numpy.ptp` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.ptp : equivalent function
 |  
 |  put(...)
 |      a.put(indices, values, mode='raise')
 |      
 |      Set ``a.flat[n] = values[n]`` for all `n` in indices.
 |      
 |      Refer to `numpy.put` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.put : equivalent function
 |  
 |  ravel(...)
 |      a.ravel([order])
 |      
 |      Return a flattened array.
 |      
 |      Refer to `numpy.ravel` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.ravel : equivalent function
 |      
 |      ndarray.flat : a flat iterator on the array.
 |  
 |  repeat(...)
 |      a.repeat(repeats, axis=None)
 |      
 |      Repeat elements of an array.
 |      
 |      Refer to `numpy.repeat` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.repeat : equivalent function
 |  
 |  reshape(...)
 |      a.reshape(shape, order='C')
 |      
 |      Returns an array containing the same data with a new shape.
 |      
 |      Refer to `numpy.reshape` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.reshape : equivalent function
 |      
 |      Notes
 |      -----
 |      Unlike the free function `numpy.reshape`, this method on `ndarray` allows
 |      the elements of the shape parameter to be passed in as separate arguments.
 |      For example, ``a.reshape(10, 11)`` is equivalent to
 |      ``a.reshape((10, 11))``.
 |  
 |  resize(...)
 |      a.resize(new_shape, refcheck=True)
 |      
 |      Change shape and size of array in-place.
 |      
 |      Parameters
 |      ----------
 |      new_shape : tuple of ints, or `n` ints
 |          Shape of resized array.
 |      refcheck : bool, optional
 |          If False, reference count will not be checked. Default is True.
 |      
 |      Returns
 |      -------
 |      None
 |      
 |      Raises
 |      ------
 |      ValueError
 |          If `a` does not own its own data or references or views to it exist,
 |          and the data memory must be changed.
 |          PyPy only: will always raise if the data memory must be changed, since
 |          there is no reliable way to determine if references or views to it
 |          exist.
 |      
 |      SystemError
 |          If the `order` keyword argument is specified. This behaviour is a
 |          bug in NumPy.
 |      
 |      See Also
 |      --------
 |      resize : Return a new array with the specified shape.
 |      
 |      Notes
 |      -----
 |      This reallocates space for the data area if necessary.
 |      
 |      Only contiguous arrays (data elements consecutive in memory) can be
 |      resized.
 |      
 |      The purpose of the reference count check is to make sure you
 |      do not use this array as a buffer for another Python object and then
 |      reallocate the memory. However, reference counts can increase in
 |      other ways so if you are sure that you have not shared the memory
 |      for this array with another Python object, then you may safely set
 |      `refcheck` to False.
 |      
 |      Examples
 |      --------
 |      Shrinking an array: array is flattened (in the order that the data are
 |      stored in memory), resized, and reshaped:
 |      
 |      >>> a = np.array([[0, 1], [2, 3]], order='C')
 |      >>> a.resize((2, 1))
 |      >>> a
 |      array([[0],
 |             [1]])
 |      
 |      >>> a = np.array([[0, 1], [2, 3]], order='F')
 |      >>> a.resize((2, 1))
 |      >>> a
 |      array([[0],
 |             [2]])
 |      
 |      Enlarging an array: as above, but missing entries are filled with zeros:
 |      
 |      >>> b = np.array([[0, 1], [2, 3]])
 |      >>> b.resize(2, 3) # new_shape parameter doesn't have to be a tuple
 |      >>> b
 |      array([[0, 1, 2],
 |             [3, 0, 0]])
 |      
 |      Referencing an array prevents resizing...
 |      
 |      >>> c = a
 |      >>> a.resize((1, 1))
 |      Traceback (most recent call last):
 |      ...
 |      ValueError: cannot resize an array that has been referenced ...
 |      
 |      Unless `refcheck` is False:
 |      
 |      >>> a.resize((1, 1), refcheck=False)
 |      >>> a
 |      array([[0]])
 |      >>> c
 |      array([[0]])
 |  
 |  round(...)
 |      a.round(decimals=0, out=None)
 |      
 |      Return `a` with each element rounded to the given number of decimals.
 |      
 |      Refer to `numpy.around` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.around : equivalent function
 |  
 |  searchsorted(...)
 |      a.searchsorted(v, side='left', sorter=None)
 |      
 |      Find indices where elements of v should be inserted in a to maintain order.
 |      
 |      For full documentation, see `numpy.searchsorted`
 |      
 |      See Also
 |      --------
 |      numpy.searchsorted : equivalent function
 |  
 |  setfield(...)
 |      a.setfield(val, dtype, offset=0)
 |      
 |      Put a value into a specified place in a field defined by a data-type.
 |      
 |      Place `val` into `a`'s field defined by `dtype` and beginning `offset`
 |      bytes into the field.
 |      
 |      Parameters
 |      ----------
 |      val : object
 |          Value to be placed in field.
 |      dtype : dtype object
 |          Data-type of the field in which to place `val`.
 |      offset : int, optional
 |          The number of bytes into the field at which to place `val`.
 |      
 |      Returns
 |      -------
 |      None
 |      
 |      See Also
 |      --------
 |      getfield
 |      
 |      Examples
 |      --------
 |      >>> x = np.eye(3)
 |      >>> x.getfield(np.float64)
 |      array([[ 1.,  0.,  0.],
 |             [ 0.,  1.,  0.],
 |             [ 0.,  0.,  1.]])
 |      >>> x.setfield(3, np.int32)
 |      >>> x.getfield(np.int32)
 |      array([[3, 3, 3],
 |             [3, 3, 3],
 |             [3, 3, 3]])
 |      >>> x
 |      array([[  1.00000000e+000,   1.48219694e-323,   1.48219694e-323],
 |             [  1.48219694e-323,   1.00000000e+000,   1.48219694e-323],
 |             [  1.48219694e-323,   1.48219694e-323,   1.00000000e+000]])
 |      >>> x.setfield(np.eye(3), np.int32)
 |      >>> x
 |      array([[ 1.,  0.,  0.],
 |             [ 0.,  1.,  0.],
 |             [ 0.,  0.,  1.]])
 |  
 |  setflags(...)
 |      a.setflags(write=None, align=None, uic=None)
 |      
 |      Set array flags WRITEABLE, ALIGNED, (WRITEBACKIFCOPY and UPDATEIFCOPY),
 |      respectively.
 |      
 |      These Boolean-valued flags affect how numpy interprets the memory
 |      area used by `a` (see Notes below). The ALIGNED flag can only
 |      be set to True if the data is actually aligned according to the type.
 |      The WRITEBACKIFCOPY and (deprecated) UPDATEIFCOPY flags can never be set
 |      to True. The flag WRITEABLE can only be set to True if the array owns its
 |      own memory, or the ultimate owner of the memory exposes a writeable buffer
 |      interface, or is a string. (The exception for string is made so that
 |      unpickling can be done without copying memory.)
 |      
 |      Parameters
 |      ----------
 |      write : bool, optional
 |          Describes whether or not `a` can be written to.
 |      align : bool, optional
 |          Describes whether or not `a` is aligned properly for its type.
 |      uic : bool, optional
 |          Describes whether or not `a` is a copy of another ""base"" array.
 |      
 |      Notes
 |      -----
 |      Array flags provide information about how the memory area used
 |      for the array is to be interpreted. There are 7 Boolean flags
 |      in use, only four of which can be changed by the user:
 |      WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED.
 |      
 |      WRITEABLE (W) the data area can be written to;
 |      
 |      ALIGNED (A) the data and strides are aligned appropriately for the hardware
 |      (as determined by the compiler);
 |      
 |      UPDATEIFCOPY (U) (deprecated), replaced by WRITEBACKIFCOPY;
 |      
 |      WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced
 |      by .base). When the C-API function PyArray_ResolveWritebackIfCopy is
 |      called, the base array will be updated with the contents of this array.
 |      
 |      All flags can be accessed using the single (upper case) letter as well
 |      as the full name.
 |      
 |      Examples
 |      --------
 |      >>> y
 |      array([[3, 1, 7],
 |             [2, 0, 0],
 |             [8, 5, 9]])
 |      >>> y.flags
 |        C_CONTIGUOUS : True
 |        F_CONTIGUOUS : False
 |        OWNDATA : True
 |        WRITEABLE : True
 |        ALIGNED : True
 |        WRITEBACKIFCOPY : False
 |        UPDATEIFCOPY : False
 |      >>> y.setflags(write=0, align=0)
 |      >>> y.flags
 |        C_CONTIGUOUS : True
 |        F_CONTIGUOUS : False
 |        OWNDATA : True
 |        WRITEABLE : False
 |        ALIGNED : False
 |        WRITEBACKIFCOPY : False
 |        UPDATEIFCOPY : False
 |      >>> y.setflags(uic=1)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: cannot set WRITEBACKIFCOPY flag to True
 |  
 |  sort(...)
 |      a.sort(axis=-1, kind='quicksort', order=None)
 |      
 |      Sort an array, in-place.
 |      
 |      Parameters
 |      ----------
 |      axis : int, optional
 |          Axis along which to sort. Default is -1, which means sort along the
 |          last axis.
 |      kind : {'quicksort', 'mergesort', 'heapsort'}, optional
 |          Sorting algorithm. Default is 'quicksort'.
 |      order : str or list of str, optional
 |          When `a` is an array with fields defined, this argument specifies
 |          which fields to compare first, second, etc.  A single field can
 |          be specified as a string, and not all fields need be specified,
 |          but unspecified fields will still be used, in the order in which
 |          they come up in the dtype, to break ties.
 |      
 |      See Also
 |      --------
 |      numpy.sort : Return a sorted copy of an array.
 |      argsort : Indirect sort.
 |      lexsort : Indirect stable sort on multiple keys.
 |      searchsorted : Find elements in sorted array.
 |      partition: Partial sort.
 |      
 |      Notes
 |      -----
 |      See ``sort`` for notes on the different sorting algorithms.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1,4], [3,1]])
 |      >>> a.sort(axis=1)
 |      >>> a
 |      array([[1, 4],
 |             [1, 3]])
 |      >>> a.sort(axis=0)
 |      >>> a
 |      array([[1, 3],
 |             [1, 4]])
 |      
 |      Use the `order` keyword to specify a field to use when sorting a
 |      structured array:
 |      
 |      >>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])
 |      >>> a.sort(order='y')
 |      >>> a
 |      array([('c', 1), ('a', 2)],
 |            dtype=[('x', '|S1'), ('y', '<i4')])
 |  
 |  squeeze(...)
 |      a.squeeze(axis=None)
 |      
 |      Remove single-dimensional entries from the shape of `a`.
 |      
 |      Refer to `numpy.squeeze` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.squeeze : equivalent function
 |  
 |  std(...)
 |      a.std(axis=None, dtype=None, out=None, ddof=0, keepdims=False)
 |      
 |      Returns the standard deviation of the array elements along given axis.
 |      
 |      Refer to `numpy.std` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.std : equivalent function
 |  
 |  sum(...)
 |      a.sum(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Return the sum of the array elements over the given axis.
 |      
 |      Refer to `numpy.sum` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.sum : equivalent function
 |  
 |  swapaxes(...)
 |      a.swapaxes(axis1, axis2)
 |      
 |      Return a view of the array with `axis1` and `axis2` interchanged.
 |      
 |      Refer to `numpy.swapaxes` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.swapaxes : equivalent function
 |  
 |  take(...)
 |      a.take(indices, axis=None, out=None, mode='raise')
 |      
 |      Return an array formed from the elements of `a` at the given indices.
 |      
 |      Refer to `numpy.take` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.take : equivalent function
 |  
 |  tobytes(...)
 |      a.tobytes(order='C')
 |      
 |      Construct Python bytes containing the raw data bytes in the array.
 |      
 |      Constructs Python bytes showing a copy of the raw contents of
 |      data memory. The bytes object can be produced in either 'C' or 'Fortran',
 |      or 'Any' order (the default is 'C'-order). 'Any' order means C-order
 |      unless the F_CONTIGUOUS flag in the array is set, in which case it
 |      means 'Fortran' order.
 |      
 |      .. versionadded:: 1.9.0
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', None}, optional
 |          Order of the data for multidimensional arrays:
 |          C, Fortran, or the same as for the original array.
 |      
 |      Returns
 |      -------
 |      s : bytes
 |          Python bytes exhibiting a copy of `a`'s raw data.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[0, 1], [2, 3]])
 |      >>> x.tobytes()
 |      b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
 |      >>> x.tobytes('C') == x.tobytes()
 |      True
 |      >>> x.tobytes('F')
 |      b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
 |  
 |  tofile(...)
 |      a.tofile(fid, sep="""", format=""%s"")
 |      
 |      Write array to a file as text or binary (default).
 |      
 |      Data is always written in 'C' order, independent of the order of `a`.
 |      The data produced by this method can be recovered using the function
 |      fromfile().
 |      
 |      Parameters
 |      ----------
 |      fid : file or str
 |          An open file object, or a string containing a filename.
 |      sep : str
 |          Separator between array items for text output.
 |          If """" (empty), a binary file is written, equivalent to
 |          ``file.write(a.tobytes())``.
 |      format : str
 |          Format string for text file output.
 |          Each entry in the array is formatted to text by first converting
 |          it to the closest Python type, and then using ""format"" % item.
 |      
 |      Notes
 |      -----
 |      This is a convenience function for quick storage of array data.
 |      Information on endianness and precision is lost, so this method is not a
 |      good choice for files intended to archive data or transport data between
 |      machines with different endianness. Some of these problems can be overcome
 |      by outputting the data as text files, at the expense of speed and file
 |      size.
 |  
 |  tolist(...)
 |      a.tolist()
 |      
 |      Return the array as a (possibly nested) list.
 |      
 |      Return a copy of the array data as a (nested) Python list.
 |      Data items are converted to the nearest compatible Python type.
 |      
 |      Parameters
 |      ----------
 |      none
 |      
 |      Returns
 |      -------
 |      y : list
 |          The possibly nested list of array elements.
 |      
 |      Notes
 |      -----
 |      The array may be recreated, ``a = np.array(a.tolist())``.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([1, 2])
 |      >>> a.tolist()
 |      [1, 2]
 |      >>> a = np.array([[1, 2], [3, 4]])
 |      >>> list(a)
 |      [array([1, 2]), array([3, 4])]
 |      >>> a.tolist()
 |      [[1, 2], [3, 4]]
 |  
 |  tostring(...)
 |      a.tostring(order='C')
 |      
 |      Construct Python bytes containing the raw data bytes in the array.
 |      
 |      Constructs Python bytes showing a copy of the raw contents of
 |      data memory. The bytes object can be produced in either 'C' or 'Fortran',
 |      or 'Any' order (the default is 'C'-order). 'Any' order means C-order
 |      unless the F_CONTIGUOUS flag in the array is set, in which case it
 |      means 'Fortran' order.
 |      
 |      This function is a compatibility alias for tobytes. Despite its name it returns bytes not strings.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', None}, optional
 |          Order of the data for multidimensional arrays:
 |          C, Fortran, or the same as for the original array.
 |      
 |      Returns
 |      -------
 |      s : bytes
 |          Python bytes exhibiting a copy of `a`'s raw data.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[0, 1], [2, 3]])
 |      >>> x.tobytes()
 |      b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
 |      >>> x.tobytes('C') == x.tobytes()
 |      True
 |      >>> x.tobytes('F')
 |      b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
 |  
 |  trace(...)
 |      a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)
 |      
 |      Return the sum along diagonals of the array.
 |      
 |      Refer to `numpy.trace` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.trace : equivalent function
 |  
 |  transpose(...)
 |      a.transpose(*axes)
 |      
 |      Returns a view of the array with axes transposed.
 |      
 |      For a 1-D array, this has no effect. (To change between column and
 |      row vectors, first cast the 1-D array into a matrix object.)
 |      For a 2-D array, this is the usual matrix transpose.
 |      For an n-D array, if axes are given, their order indicates how the
 |      axes are permuted (see Examples). If axes are not provided and
 |      ``a.shape = (i[0], i[1], ... i[n-2], i[n-1])``, then
 |      ``a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0])``.
 |      
 |      Parameters
 |      ----------
 |      axes : None, tuple of ints, or `n` ints
 |      
 |       * None or no argument: reverses the order of the axes.
 |      
 |       * tuple of ints: `i` in the `j`-th place in the tuple means `a`'s
 |         `i`-th axis becomes `a.transpose()`'s `j`-th axis.
 |      
 |       * `n` ints: same as an n-tuple of the same ints (this form is
 |         intended simply as a ""convenience"" alternative to the tuple form)
 |      
 |      Returns
 |      -------
 |      out : ndarray
 |          View of `a`, with axes suitably permuted.
 |      
 |      See Also
 |      --------
 |      ndarray.T : Array property returning the array transposed.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1, 2], [3, 4]])
 |      >>> a
 |      array([[1, 2],
 |             [3, 4]])
 |      >>> a.transpose()
 |      array([[1, 3],
 |             [2, 4]])
 |      >>> a.transpose((1, 0))
 |      array([[1, 3],
 |             [2, 4]])
 |      >>> a.transpose(1, 0)
 |      array([[1, 3],
 |             [2, 4]])
 |  
 |  var(...)
 |      a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False)
 |      
 |      Returns the variance of the array elements, along given axis.
 |      
 |      Refer to `numpy.var` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.var : equivalent function
 |  
 |  view(...)
 |      a.view(dtype=None, type=None)
 |      
 |      New view of array with the same data.
 |      
 |      Parameters
 |      ----------
 |      dtype : data-type or ndarray sub-class, optional
 |          Data-type descriptor of the returned view, e.g., float32 or int16. The
 |          default, None, results in the view having the same data-type as `a`.
 |          This argument can also be specified as an ndarray sub-class, which
 |          then specifies the type of the returned object (this is equivalent to
 |          setting the ``type`` parameter).
 |      type : Python type, optional
 |          Type of the returned view, e.g., ndarray or matrix.  Again, the
 |          default None results in type preservation.
 |      
 |      Notes
 |      -----
 |      ``a.view()`` is used two different ways:
 |      
 |      ``a.view(some_dtype)`` or ``a.view(dtype=some_dtype)`` constructs a view
 |      of the array's memory with a different data-type.  This can cause a
 |      reinterpretation of the bytes of memory.
 |      
 |      ``a.view(ndarray_subclass)`` or ``a.view(type=ndarray_subclass)`` just
 |      returns an instance of `ndarray_subclass` that looks at the same array
 |      (same shape, dtype, etc.)  This does not cause a reinterpretation of the
 |      memory.
 |      
 |      For ``a.view(some_dtype)``, if ``some_dtype`` has a different number of
 |      bytes per entry than the previous dtype (for example, converting a
 |      regular array to a structured array), then the behavior of the view
 |      cannot be predicted just from the superficial appearance of ``a`` (shown
 |      by ``print(a)``). It also depends on exactly how ``a`` is stored in
 |      memory. Therefore if ``a`` is C-ordered versus fortran-ordered, versus
 |      defined as a slice or transpose, etc., the view may give different
 |      results.
 |      
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])
 |      
 |      Viewing array data using a different type and dtype:
 |      
 |      >>> y = x.view(dtype=np.int16, type=np.matrix)
 |      >>> y
 |      matrix([[513]], dtype=int16)
 |      >>> print(type(y))
 |      <class 'numpy.matrixlib.defmatrix.matrix'>
 |      
 |      Creating a view on a structured array so it can be used in calculations
 |      
 |      >>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)])
 |      >>> xv = x.view(dtype=np.int8).reshape(-1,2)
 |      >>> xv
 |      array([[1, 2],
 |             [3, 4]], dtype=int8)
 |      >>> xv.mean(0)
 |      array([ 2.,  3.])
 |      
 |      Making changes to the view changes the underlying array
 |      
 |      >>> xv[0,1] = 20
 |      >>> print(x)
 |      [(1, 20) (3, 4)]
 |      
 |      Using a view to convert an array to a recarray:
 |      
 |      >>> z = x.view(np.recarray)
 |      >>> z.a
 |      array([1], dtype=int8)
 |      
 |      Views share data:
 |      
 |      >>> x[0] = (9, 10)
 |      >>> z[0]
 |      (9, 10)
 |      
 |      Views that change the dtype size (bytes per entry) should normally be
 |      avoided on arrays defined by slices, transposes, fortran-ordering, etc.:
 |      
 |      >>> x = np.array([[1,2,3],[4,5,6]], dtype=np.int16)
 |      >>> y = x[:, 0:2]
 |      >>> y
 |      array([[1, 2],
 |             [4, 5]], dtype=int16)
 |      >>> y.view(dtype=[('width', np.int16), ('length', np.int16)])
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: new type not compatible with array.
 |      >>> z = y.copy()
 |      >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
 |      array([[(1, 2)],
 |             [(4, 5)]], dtype=[('width', '<i2'), ('length', '<i2')])
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  T
 |      Same as self.transpose(), except that self is returned if
 |      self.ndim < 2.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[1.,2.],[3.,4.]])
 |      >>> x
 |      array([[ 1.,  2.],
 |             [ 3.,  4.]])
 |      >>> x.T
 |      array([[ 1.,  3.],
 |             [ 2.,  4.]])
 |      >>> x = np.array([1.,2.,3.,4.])
 |      >>> x
 |      array([ 1.,  2.,  3.,  4.])
 |      >>> x.T
 |      array([ 1.,  2.,  3.,  4.])
 |  
 |  __array_finalize__
 |      None.
 |  
 |  __array_interface__
 |      Array protocol: Python side.
 |  
 |  __array_priority__
 |      Array priority.
 |  
 |  __array_struct__
 |      Array protocol: C-struct side.
 |  
 |  base
 |      Base object if memory is from some other object.
 |      
 |      Examples
 |      --------
 |      The base of an array that owns its memory is None:
 |      
 |      >>> x = np.array([1,2,3,4])
 |      >>> x.base is None
 |      True
 |      
 |      Slicing creates a view, whose memory is shared with x:
 |      
 |      >>> y = x[2:]
 |      >>> y.base is x
 |      True
 |  
 |  ctypes
 |      An object to simplify the interaction of the array with the ctypes
 |      module.
 |      
 |      This attribute creates an object that makes it easier to use arrays
 |      when calling shared libraries with the ctypes module. The returned
 |      object has, among others, data, shape, and strides attributes (see
 |      Notes below) which themselves return ctypes objects that can be used
 |      as arguments to a shared library.
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      c : Python object
 |          Possessing attributes data, shape, strides, etc.
 |      
 |      See Also
 |      --------
 |      numpy.ctypeslib
 |      
 |      Notes
 |      -----
 |      Below are the public attributes of this object which were documented
 |      in ""Guide to NumPy"" (we have omitted undocumented public attributes,
 |      as well as documented private attributes):
 |      
 |      * data: A pointer to the memory area of the array as a Python integer.
 |        This memory area may contain data that is not aligned, or not in correct
 |        byte-order. The memory area may not even be writeable. The array
 |        flags and data-type of this array should be respected when passing this
 |        attribute to arbitrary C-code to avoid trouble that can include Python
 |        crashing. User Beware! The value of this attribute is exactly the same
 |        as self._array_interface_['data'][0].
 |      
 |      * shape (c_intp*self.ndim): A ctypes array of length self.ndim where
 |        the basetype is the C-integer corresponding to dtype('p') on this
 |        platform. This base-type could be c_int, c_long, or c_longlong
 |        depending on the platform. The c_intp type is defined accordingly in
 |        numpy.ctypeslib. The ctypes array contains the shape of the underlying
 |        array.
 |      
 |      * strides (c_intp*self.ndim): A ctypes array of length self.ndim where
 |        the basetype is the same as for the shape attribute. This ctypes array
 |        contains the strides information from the underlying array. This strides
 |        information is important for showing how many bytes must be jumped to
 |        get to the next element in the array.
 |      
 |      * data_as(obj): Return the data pointer cast to a particular c-types object.
 |        For example, calling self._as_parameter_ is equivalent to
 |        self.data_as(ctypes.c_void_p). Perhaps you want to use the data as a
 |        pointer to a ctypes array of floating-point data:
 |        self.data_as(ctypes.POINTER(ctypes.c_double)).
 |      
 |      * shape_as(obj): Return the shape tuple as an array of some other c-types
 |        type. For example: self.shape_as(ctypes.c_short).
 |      
 |      * strides_as(obj): Return the strides tuple as an array of some other
 |        c-types type. For example: self.strides_as(ctypes.c_longlong).
 |      
 |      Be careful using the ctypes attribute - especially on temporary
 |      arrays or arrays constructed on the fly. For example, calling
 |      ``(a+b).ctypes.data_as(ctypes.c_void_p)`` returns a pointer to memory
 |      that is invalid because the array created as (a+b) is deallocated
 |      before the next Python statement. You can avoid this problem using
 |      either ``c=a+b`` or ``ct=(a+b).ctypes``. In the latter case, ct will
 |      hold a reference to the array until ct is deleted or re-assigned.
 |      
 |      If the ctypes module is not available, then the ctypes attribute
 |      of array objects still returns something useful, but ctypes objects
 |      are not returned and errors may be raised instead. In particular,
 |      the object will still have the as parameter attribute which will
 |      return an integer equal to the data attribute.
 |      
 |      Examples
 |      --------
 |      >>> import ctypes
 |      >>> x
 |      array([[0, 1],
 |             [2, 3]])
 |      >>> x.ctypes.data
 |      30439712
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long))
 |      <ctypes.LP_c_long object at 0x01F01300>
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)).contents
 |      c_long(0)
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_longlong)).contents
 |      c_longlong(4294967296L)
 |      >>> x.ctypes.shape
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FFD580>
 |      >>> x.ctypes.shape_as(ctypes.c_long)
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
 |      >>> x.ctypes.strides
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
 |      >>> x.ctypes.strides_as(ctypes.c_longlong)
 |      <numpy.core._internal.c_longlong_Array_2 object at 0x01F01300>
 |  
 |  data
 |      Python buffer object pointing to the start of the array's data.
 |  
 |  dtype
 |      Data-type of the array's elements.
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      d : numpy dtype object
 |      
 |      See Also
 |      --------
 |      numpy.dtype
 |      
 |      Examples
 |      --------
 |      >>> x
 |      array([[0, 1],
 |             [2, 3]])
 |      >>> x.dtype
 |      dtype('int32')
 |      >>> type(x.dtype)
 |      <type 'numpy.dtype'>
 |  
 |  flags
 |      Information about the memory layout of the array.
 |      
 |      Attributes
 |      ----------
 |      C_CONTIGUOUS (C)
 |          The data is in a single, C-style contiguous segment.
 |      F_CONTIGUOUS (F)
 |          The data is in a single, Fortran-style contiguous segment.
 |      OWNDATA (O)
 |          The array owns the memory it uses or borrows it from another object.
 |      WRITEABLE (W)
 |          The data area can be written to.  Setting this to False locks
 |          the data, making it read-only.  A view (slice, etc.) inherits WRITEABLE
 |          from its base array at creation time, but a view of a writeable
 |          array may be subsequently locked while the base array remains writeable.
 |          (The opposite is not true, in that a view of a locked array may not
 |          be made writeable.  However, currently, locking a base object does not
 |          lock any views that already reference it, so under that circumstance it
 |          is possible to alter the contents of a locked array via a previously
 |          created writeable view onto it.)  Attempting to change a non-writeable
 |          array raises a RuntimeError exception.
 |      ALIGNED (A)
 |          The data and all elements are aligned appropriately for the hardware.
 |      WRITEBACKIFCOPY (X)
 |          This array is a copy of some other array. The C-API function
 |          PyArray_ResolveWritebackIfCopy must be called before deallocating
 |          to the base array will be updated with the contents of this array.
 |      UPDATEIFCOPY (U)
 |          (Deprecated, use WRITEBACKIFCOPY) This array is a copy of some other array.
 |          When this array is
 |          deallocated, the base array will be updated with the contents of
 |          this array.
 |      FNC
 |          F_CONTIGUOUS and not C_CONTIGUOUS.
 |      FORC
 |          F_CONTIGUOUS or C_CONTIGUOUS (one-segment test).
 |      BEHAVED (B)
 |          ALIGNED and WRITEABLE.
 |      CARRAY (CA)
 |          BEHAVED and C_CONTIGUOUS.
 |      FARRAY (FA)
 |          BEHAVED and F_CONTIGUOUS and not C_CONTIGUOUS.
 |      
 |      Notes
 |      -----
 |      The `flags` object can be accessed dictionary-like (as in ``a.flags['WRITEABLE']``),
 |      or by using lowercased attribute names (as in ``a.flags.writeable``). Short flag
 |      names are only supported in dictionary access.
 |      
 |      Only the WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED flags can be
 |      changed by the user, via direct assignment to the attribute or dictionary
 |      entry, or by calling `ndarray.setflags`.
 |      
 |      The array flags cannot be set arbitrarily:
 |      
 |      - UPDATEIFCOPY can only be set ``False``.
 |      - WRITEBACKIFCOPY can only be set ``False``.
 |      - ALIGNED can only be set ``True`` if the data is truly aligned.
 |      - WRITEABLE can only be set ``True`` if the array owns its own memory
 |        or the ultimate owner of the memory exposes a writeable buffer
 |        interface or is a string.
 |      
 |      Arrays can be both C-style and Fortran-style contiguous simultaneously.
 |      This is clear for 1-dimensional arrays, but can also be true for higher
 |      dimensional arrays.
 |      
 |      Even for contiguous arrays a stride for a given dimension
 |      ``arr.strides[dim]`` may be *arbitrary* if ``arr.shape[dim] == 1``
 |      or the array has no elements.
 |      It does *not* generally hold that ``self.strides[-1] == self.itemsize``
 |      for C-style contiguous arrays or ``self.strides[0] == self.itemsize`` for
 |      Fortran-style contiguous arrays is true.
 |  
 |  flat
 |      A 1-D iterator over the array.
 |      
 |      This is a `numpy.flatiter` instance, which acts similarly to, but is not
 |      a subclass of, Python's built-in iterator object.
 |      
 |      See Also
 |      --------
 |      flatten : Return a copy of the array collapsed into one dimension.
 |      
 |      flatiter
 |      
 |      Examples
 |      --------
 |      >>> x = np.arange(1, 7).reshape(2, 3)
 |      >>> x
 |      array([[1, 2, 3],
 |             [4, 5, 6]])
 |      >>> x.flat[3]
 |      4
 |      >>> x.T
 |      array([[1, 4],
 |             [2, 5],
 |             [3, 6]])
 |      >>> x.T.flat[3]
 |      5
 |      >>> type(x.flat)
 |      <type 'numpy.flatiter'>
 |      
 |      An assignment example:
 |      
 |      >>> x.flat = 3; x
 |      array([[3, 3, 3],
 |             [3, 3, 3]])
 |      >>> x.flat[[1,4]] = 1; x
 |      array([[3, 1, 3],
 |             [3, 1, 3]])
 |  
 |  imag
 |      The imaginary part of the array.
 |      
 |      Examples
 |      --------
 |      >>> x = np.sqrt([1+0j, 0+1j])
 |      >>> x.imag
 |      array([ 0.        ,  0.70710678])
 |      >>> x.imag.dtype
 |      dtype('float64')
 |  
 |  itemsize
 |      Length of one array element in bytes.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1,2,3], dtype=np.float64)
 |      >>> x.itemsize
 |      8
 |      >>> x = np.array([1,2,3], dtype=np.complex128)
 |      >>> x.itemsize
 |      16
 |  
 |  nbytes
 |      Total bytes consumed by the elements of the array.
 |      
 |      Notes
 |      -----
 |      Does not include memory consumed by non-element attributes of the
 |      array object.
 |      
 |      Examples
 |      --------
 |      >>> x = np.zeros((3,5,2), dtype=np.complex128)
 |      >>> x.nbytes
 |      480
 |      >>> np.prod(x.shape) * x.itemsize
 |      480
 |  
 |  ndim
 |      Number of array dimensions.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 3])
 |      >>> x.ndim
 |      1
 |      >>> y = np.zeros((2, 3, 4))
 |      >>> y.ndim
 |      3
 |  
 |  real
 |      The real part of the array.
 |      
 |      Examples
 |      --------
 |      >>> x = np.sqrt([1+0j, 0+1j])
 |      >>> x.real
 |      array([ 1.        ,  0.70710678])
 |      >>> x.real.dtype
 |      dtype('float64')
 |      
 |      See Also
 |      --------
 |      numpy.real : equivalent function
 |  
 |  shape
 |      Tuple of array dimensions.
 |      
 |      The shape property is usually used to get the current shape of an array,
 |      but may also be used to reshape the array in-place by assigning a tuple of
 |      array dimensions to it.  As with `numpy.reshape`, one of the new shape
 |      dimensions can be -1, in which case its value is inferred from the size of
 |      the array and the remaining dimensions. Reshaping an array in-place will
 |      fail if a copy is required.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 3, 4])
 |      >>> x.shape
 |      (4,)
 |      >>> y = np.zeros((2, 3, 4))
 |      >>> y.shape
 |      (2, 3, 4)
 |      >>> y.shape = (3, 8)
 |      >>> y
 |      array([[ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
 |             [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
 |             [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.]])
 |      >>> y.shape = (3, 6)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      ValueError: total size of new array must be unchanged
 |      >>> np.zeros((4,2))[::2].shape = (-1,)
 |      Traceback (most recent call last):
 |        File ""<stdin>"", line 1, in <module>
 |      AttributeError: incompatible shape for a non-contiguous array
 |      
 |      See Also
 |      --------
 |      numpy.reshape : similar function
 |      ndarray.reshape : similar method
 |  
 |  size
 |      Number of elements in the array.
 |      
 |      Equivalent to ``np.prod(a.shape)``, i.e., the product of the array's
 |      dimensions.
 |      
 |      Examples
 |      --------
 |      >>> x = np.zeros((3, 5, 2), dtype=np.complex128)
 |      >>> x.size
 |      30
 |      >>> np.prod(x.shape)
 |      30
 |  
 |  strides
 |      Tuple of bytes to step in each dimension when traversing an array.
 |      
 |      The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a`
 |      is::
 |      
 |          offset = sum(np.array(i) * a.strides)
 |      
 |      A more detailed explanation of strides can be found in the
 |      ""ndarray.rst"" file in the NumPy reference guide.
 |      
 |      Notes
 |      -----
 |      Imagine an array of 32-bit integers (each 4 bytes)::
 |      
 |        x = np.array([[0, 1, 2, 3, 4],
 |                      [5, 6, 7, 8, 9]], dtype=np.int32)
 |      
 |      This array is stored in memory as 40 bytes, one after the other
 |      (known as a contiguous block of memory).  The strides of an array tell
 |      us how many bytes we have to skip in memory to move to the next position
 |      along a certain axis.  For example, we have to skip 4 bytes (1 value) to
 |      move to the next column, but 20 bytes (5 values) to get to the same
 |      position in the next row.  As such, the strides for the array `x` will be
 |      ``(20, 4)``.
 |      
 |      See Also
 |      --------
 |      numpy.lib.stride_tricks.as_strided
 |      
 |      Examples
 |      --------
 |      >>> y = np.reshape(np.arange(2*3*4), (2,3,4))
 |      >>> y
 |      array([[[ 0,  1,  2,  3],
 |              [ 4,  5,  6,  7],
 |              [ 8,  9, 10, 11]],
 |             [[12, 13, 14, 15],
 |              [16, 17, 18, 19],
 |              [20, 21, 22, 23]]])
 |      >>> y.strides
 |      (48, 16, 4)
 |      >>> y[1,1,1]
 |      17
 |      >>> offset=sum(y.strides * np.array((1,1,1)))
 |      >>> offset/y.itemsize
 |      17
 |      
 |      >>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0)
 |      >>> x.strides
 |      (32, 4, 224, 1344)
 |      >>> i = np.array([3,5,2,2])
 |      >>> offset = sum(i * x.strides)
 |      >>> x[3,5,2,2]
 |      813
 |      >>> offset / x.itemsize
 |      813
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.mmio.ones,io.mmio,ones,"Python Library Documentation: function ones in module numpy.core.numeric

ones(shape, dtype=None, order='C')
    Return a new array of given shape and type, filled with ones.
    
    Parameters
    ----------
    shape : int or sequence of ints
        Shape of the new array, e.g., ``(2, 3)`` or ``2``.
    dtype : data-type, optional
        The desired data-type for the array, e.g., `numpy.int8`.  Default is
        `numpy.float64`.
    order : {'C', 'F'}, optional
        Whether to store multidimensional data in C- or Fortran-contiguous
        (row- or column-wise) order in memory.
    
    Returns
    -------
    out : ndarray
        Array of ones with the given shape, dtype, and order.
    
    See Also
    --------
    zeros, ones_like
    
    Examples
    --------
    >>> np.ones(5)
    array([ 1.,  1.,  1.,  1.,  1.])
    
    >>> np.ones((5,), dtype=int)
    array([1, 1, 1, 1, 1])
    
    >>> np.ones((2, 1))
    array([[ 1.],
           [ 1.]])
    
    >>> s = (2,2)
    >>> np.ones(s)
    array([[ 1.,  1.],
           [ 1.,  1.]])
",function,"(""(shape, dtype=None, order='C')"",)",scipy,1.1.0,scipy.io.mmio.ones,io.mmio,ones,"Python Library Documentation: function ones in module numpy.core.numeric

ones(shape, dtype=None, order='C')
    Return a new array of given shape and type, filled with ones.
    
    Parameters
    ----------
    shape : int or sequence of ints
        Shape of the new array, e.g., ``(2, 3)`` or ``2``.
    dtype : data-type, optional
        The desired data-type for the array, e.g., `numpy.int8`.  Default is
        `numpy.float64`.
    order : {'C', 'F'}, optional
        Whether to store multidimensional data in C- or Fortran-contiguous
        (row- or column-wise) order in memory.
    
    Returns
    -------
    out : ndarray
        Array of ones with the given shape, dtype, and order.
    
    See Also
    --------
    zeros, ones_like
    
    Examples
    --------
    >>> np.ones(5)
    array([ 1.,  1.,  1.,  1.,  1.])
    
    >>> np.ones((5,), dtype=int)
    array([1, 1, 1, 1, 1])
    
    >>> np.ones((2, 1))
    array([[ 1.],
           [ 1.]])
    
    >>> s = (2,2)
    >>> np.ones(s)
    array([[ 1.,  1.],
           [ 1.,  1.]])
",function,"('shape', 'dtype', 'order')","(nan, None, 'C')","(nan, 'NoneType', 'str')","('arg_info', 'arg_info', 'arg_info')","(""(shape, dtype=None, order='C')"",)"
scipy,1.1.0,scipy.io.mmio.real,io.mmio,real,"Python Library Documentation: function real in module numpy.lib.type_check

real(val)
    Return the real part of the complex argument.
    
    Parameters
    ----------
    val : array_like
        Input array.
    
    Returns
    -------
    out : ndarray or scalar
        The real component of the complex argument. If `val` is real, the type
        of `val` is used for the output.  If `val` has complex elements, the
        returned type is float.
    
    See Also
    --------
    real_if_close, imag, angle
    
    Examples
    --------
    >>> a = np.array([1+2j, 3+4j, 5+6j])
    >>> a.real
    array([ 1.,  3.,  5.])
    >>> a.real = 9
    >>> a
    array([ 9.+2.j,  9.+4.j,  9.+6.j])
    >>> a.real = np.array([9, 8, 7])
    >>> a
    array([ 9.+2.j,  8.+4.j,  7.+6.j])
    >>> np.real(1 + 1j)
    1.0
",function,"('(val)',)",scipy,1.1.0,scipy.io.mmio.real,io.mmio,real,"Python Library Documentation: function real in module numpy.lib.type_check

real(val)
    Return the real part of the complex argument.
    
    Parameters
    ----------
    val : array_like
        Input array.
    
    Returns
    -------
    out : ndarray or scalar
        The real component of the complex argument. If `val` is real, the type
        of `val` is used for the output.  If `val` has complex elements, the
        returned type is float.
    
    See Also
    --------
    real_if_close, imag, angle
    
    Examples
    --------
    >>> a = np.array([1+2j, 3+4j, 5+6j])
    >>> a.real
    array([ 1.,  3.,  5.])
    >>> a.real = 9
    >>> a
    array([ 9.+2.j,  9.+4.j,  9.+6.j])
    >>> a.real = np.array([9, 8, 7])
    >>> a
    array([ 9.+2.j,  8.+4.j,  7.+6.j])
    >>> np.real(1 + 1j)
    1.0
",function,"('val',)","(nan,)","(nan,)","('arg_info',)","('(val)',)"
scipy,1.1.0,scipy.io.mmio.savetxt,io.mmio,savetxt,"Python Library Documentation: function savetxt in module numpy.lib.npyio

savetxt(fname, X, fmt='%.18e', delimiter=' ', newline='\n', header='', footer='', comments='# ', encoding=None)
    Save an array to a text file.
    
    Parameters
    ----------
    fname : filename or file handle
        If the filename ends in ``.gz``, the file is automatically saved in
        compressed gzip format.  `loadtxt` understands gzipped files
        transparently.
    X : 1D or 2D array_like
        Data to be saved to a text file.
    fmt : str or sequence of strs, optional
        A single format (%10.5f), a sequence of formats, or a
        multi-format string, e.g. 'Iteration %d -- %10.5f', in which
        case `delimiter` is ignored. For complex `X`, the legal options
        for `fmt` are:
            a) a single specifier, `fmt='%.4e'`, resulting in numbers formatted
               like `' (%s+%sj)' % (fmt, fmt)`
            b) a full string specifying every real and imaginary part, e.g.
               `' %.4e %+.4ej %.4e %+.4ej %.4e %+.4ej'` for 3 columns
            c) a list of specifiers, one per column - in this case, the real
               and imaginary part must have separate specifiers,
               e.g. `['%.3e + %.3ej', '(%.15e%+.15ej)']` for 2 columns
    delimiter : str, optional
        String or character separating columns.
    newline : str, optional
        String or character separating lines.
    
        .. versionadded:: 1.5.0
    header : str, optional
        String that will be written at the beginning of the file.
    
        .. versionadded:: 1.7.0
    footer : str, optional
        String that will be written at the end of the file.
    
        .. versionadded:: 1.7.0
    comments : str, optional
        String that will be prepended to the ``header`` and ``footer`` strings,
        to mark them as comments. Default: '# ',  as expected by e.g.
        ``numpy.loadtxt``.
    
        .. versionadded:: 1.7.0
    encoding : {None, str}, optional
        Encoding used to encode the outputfile. Does not apply to output
        streams. If the encoding is something other than 'bytes' or 'latin1'
        you will not be able to load the file in NumPy versions < 1.14. Default
        is 'latin1'.
    
        .. versionadded:: 1.14.0
    
    
    See Also
    --------
    save : Save an array to a binary file in NumPy ``.npy`` format
    savez : Save several arrays into an uncompressed ``.npz`` archive
    savez_compressed : Save several arrays into a compressed ``.npz`` archive
    
    Notes
    -----
    Further explanation of the `fmt` parameter
    (``%[flag]width[.precision]specifier``):
    
    flags:
        ``-`` : left justify
    
        ``+`` : Forces to precede result with + or -.
    
        ``0`` : Left pad the number with zeros instead of space (see width).
    
    width:
        Minimum number of characters to be printed. The value is not truncated
        if it has more characters.
    
    precision:
        - For integer specifiers (eg. ``d,i,o,x``), the minimum number of
          digits.
        - For ``e, E`` and ``f`` specifiers, the number of digits to print
          after the decimal point.
        - For ``g`` and ``G``, the maximum number of significant digits.
        - For ``s``, the maximum number of characters.
    
    specifiers:
        ``c`` : character
    
        ``d`` or ``i`` : signed decimal integer
    
        ``e`` or ``E`` : scientific notation with ``e`` or ``E``.
    
        ``f`` : decimal floating point
    
        ``g,G`` : use the shorter of ``e,E`` or ``f``
    
        ``o`` : signed octal
    
        ``s`` : string of characters
    
        ``u`` : unsigned decimal integer
    
        ``x,X`` : unsigned hexadecimal integer
    
    This explanation of ``fmt`` is not complete, for an exhaustive
    specification see [1]_.
    
    References
    ----------
    .. [1] `Format Specification Mini-Language
           <http://docs.python.org/library/string.html#
           format-specification-mini-language>`_, Python Documentation.
    
    Examples
    --------
    >>> x = y = z = np.arange(0.0,5.0,1.0)
    >>> np.savetxt('test.out', x, delimiter=',')   # X is an array
    >>> np.savetxt('test.out', (x,y,z))   # x,y,z equal sized 1D arrays
    >>> np.savetxt('test.out', x, fmt='%1.4e')   # use exponential notation
",function,"(""(fname, X, fmt='%.18e', delimiter=' ', newline='\\n', header='', footer='', comments='# ', encoding=None)"",)",scipy,1.1.0,scipy.io.mmio.savetxt,io.mmio,savetxt,"Python Library Documentation: function savetxt in module numpy.lib.npyio

savetxt(fname, X, fmt='%.18e', delimiter=' ', newline='\n', header='', footer='', comments='# ', encoding=None)
    Save an array to a text file.
    
    Parameters
    ----------
    fname : filename or file handle
        If the filename ends in ``.gz``, the file is automatically saved in
        compressed gzip format.  `loadtxt` understands gzipped files
        transparently.
    X : 1D or 2D array_like
        Data to be saved to a text file.
    fmt : str or sequence of strs, optional
        A single format (%10.5f), a sequence of formats, or a
        multi-format string, e.g. 'Iteration %d -- %10.5f', in which
        case `delimiter` is ignored. For complex `X`, the legal options
        for `fmt` are:
            a) a single specifier, `fmt='%.4e'`, resulting in numbers formatted
               like `' (%s+%sj)' % (fmt, fmt)`
            b) a full string specifying every real and imaginary part, e.g.
               `' %.4e %+.4ej %.4e %+.4ej %.4e %+.4ej'` for 3 columns
            c) a list of specifiers, one per column - in this case, the real
               and imaginary part must have separate specifiers,
               e.g. `['%.3e + %.3ej', '(%.15e%+.15ej)']` for 2 columns
    delimiter : str, optional
        String or character separating columns.
    newline : str, optional
        String or character separating lines.
    
        .. versionadded:: 1.5.0
    header : str, optional
        String that will be written at the beginning of the file.
    
        .. versionadded:: 1.7.0
    footer : str, optional
        String that will be written at the end of the file.
    
        .. versionadded:: 1.7.0
    comments : str, optional
        String that will be prepended to the ``header`` and ``footer`` strings,
        to mark them as comments. Default: '# ',  as expected by e.g.
        ``numpy.loadtxt``.
    
        .. versionadded:: 1.7.0
    encoding : {None, str}, optional
        Encoding used to encode the outputfile. Does not apply to output
        streams. If the encoding is something other than 'bytes' or 'latin1'
        you will not be able to load the file in NumPy versions < 1.14. Default
        is 'latin1'.
    
        .. versionadded:: 1.14.0
    
    
    See Also
    --------
    save : Save an array to a binary file in NumPy ``.npy`` format
    savez : Save several arrays into an uncompressed ``.npz`` archive
    savez_compressed : Save several arrays into a compressed ``.npz`` archive
    
    Notes
    -----
    Further explanation of the `fmt` parameter
    (``%[flag]width[.precision]specifier``):
    
    flags:
        ``-`` : left justify
    
        ``+`` : Forces to precede result with + or -.
    
        ``0`` : Left pad the number with zeros instead of space (see width).
    
    width:
        Minimum number of characters to be printed. The value is not truncated
        if it has more characters.
    
    precision:
        - For integer specifiers (eg. ``d,i,o,x``), the minimum number of
          digits.
        - For ``e, E`` and ``f`` specifiers, the number of digits to print
          after the decimal point.
        - For ``g`` and ``G``, the maximum number of significant digits.
        - For ``s``, the maximum number of characters.
    
    specifiers:
        ``c`` : character
    
        ``d`` or ``i`` : signed decimal integer
    
        ``e`` or ``E`` : scientific notation with ``e`` or ``E``.
    
        ``f`` : decimal floating point
    
        ``g,G`` : use the shorter of ``e,E`` or ``f``
    
        ``o`` : signed octal
    
        ``s`` : string of characters
    
        ``u`` : unsigned decimal integer
    
        ``x,X`` : unsigned hexadecimal integer
    
    This explanation of ``fmt`` is not complete, for an exhaustive
    specification see [1]_.
    
    References
    ----------
    .. [1] `Format Specification Mini-Language
           <http://docs.python.org/library/string.html#
           format-specification-mini-language>`_, Python Documentation.
    
    Examples
    --------
    >>> x = y = z = np.arange(0.0,5.0,1.0)
    >>> np.savetxt('test.out', x, delimiter=',')   # X is an array
    >>> np.savetxt('test.out', (x,y,z))   # x,y,z equal sized 1D arrays
    >>> np.savetxt('test.out', x, fmt='%1.4e')   # use exponential notation
",function,"('fname', 'X', 'fmt', 'delimiter', 'newline', 'header', 'footer', 'comments', 'encoding')","(nan, nan, '%.18e', ' ', '\n', '', '', '# ', None)","(nan, nan, nan, nan, nan, nan, nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(fname, X, fmt='%.18e', delimiter=' ', newline='\\n', header='', footer='', comments='# ', encoding=None)"",)"
scipy,1.1.0,scipy.io.mmio.vstack,io.mmio,vstack,"Python Library Documentation: function vstack in module numpy.core.shape_base

vstack(tup)
    Stack arrays in sequence vertically (row wise).
    
    This is equivalent to concatenation along the first axis after 1-D arrays
    of shape `(N,)` have been reshaped to `(1,N)`. Rebuilds arrays divided by
    `vsplit`.
    
    This function makes most sense for arrays with up to 3 dimensions. For
    instance, for pixel-data with a height (first axis), width (second axis),
    and r/g/b channels (third axis). The functions `concatenate`, `stack` and
    `block` provide more general stacking and concatenation operations.
    
    Parameters
    ----------
    tup : sequence of ndarrays
        The arrays must have the same shape along all but the first axis.
        1-D arrays must have the same length.
    
    Returns
    -------
    stacked : ndarray
        The array formed by stacking the given arrays, will be at least 2-D.
    
    See Also
    --------
    stack : Join a sequence of arrays along a new axis.
    hstack : Stack arrays in sequence horizontally (column wise).
    dstack : Stack arrays in sequence depth wise (along third dimension).
    concatenate : Join a sequence of arrays along an existing axis.
    vsplit : Split array into a list of multiple sub-arrays vertically.
    block : Assemble arrays from blocks.
    
    Examples
    --------
    >>> a = np.array([1, 2, 3])
    >>> b = np.array([2, 3, 4])
    >>> np.vstack((a,b))
    array([[1, 2, 3],
           [2, 3, 4]])
    
    >>> a = np.array([[1], [2], [3]])
    >>> b = np.array([[2], [3], [4]])
    >>> np.vstack((a,b))
    array([[1],
           [2],
           [3],
           [2],
           [3],
           [4]])
",function,"('(tup)',)",scipy,1.1.0,scipy.io.mmio.vstack,io.mmio,vstack,"Python Library Documentation: function vstack in module numpy.core.shape_base

vstack(tup)
    Stack arrays in sequence vertically (row wise).
    
    This is equivalent to concatenation along the first axis after 1-D arrays
    of shape `(N,)` have been reshaped to `(1,N)`. Rebuilds arrays divided by
    `vsplit`.
    
    This function makes most sense for arrays with up to 3 dimensions. For
    instance, for pixel-data with a height (first axis), width (second axis),
    and r/g/b channels (third axis). The functions `concatenate`, `stack` and
    `block` provide more general stacking and concatenation operations.
    
    Parameters
    ----------
    tup : sequence of ndarrays
        The arrays must have the same shape along all but the first axis.
        1-D arrays must have the same length.
    
    Returns
    -------
    stacked : ndarray
        The array formed by stacking the given arrays, will be at least 2-D.
    
    See Also
    --------
    stack : Join a sequence of arrays along a new axis.
    hstack : Stack arrays in sequence horizontally (column wise).
    dstack : Stack arrays in sequence depth wise (along third dimension).
    concatenate : Join a sequence of arrays along an existing axis.
    vsplit : Split array into a list of multiple sub-arrays vertically.
    block : Assemble arrays from blocks.
    
    Examples
    --------
    >>> a = np.array([1, 2, 3])
    >>> b = np.array([2, 3, 4])
    >>> np.vstack((a,b))
    array([[1, 2, 3],
           [2, 3, 4]])
    
    >>> a = np.array([[1], [2], [3]])
    >>> b = np.array([[2], [3], [4]])
    >>> np.vstack((a,b))
    array([[1],
           [2],
           [3],
           [2],
           [3],
           [4]])
",function,"('tup',)","(nan,)","(nan,)","('arg_info',)","('(tup)',)"
scipy,1.1.0,scipy.io.mmread,io,mmread,"Python Library Documentation: function mmread in module scipy.io.mmio

mmread(source)
    Reads the contents of a Matrix Market file-like 'source' into a matrix.
    
    Parameters
    ----------
    source : str or file-like
        Matrix Market filename (extensions .mtx, .mtz.gz)
        or open file-like object.
    
    Returns
    -------
    a : ndarray or coo_matrix
        Dense or sparse matrix depending on the matrix format in the
        Matrix Market file.
",function,"('(source)',)",scipy,1.1.0,scipy.io.mmread,io,mmread,"Python Library Documentation: function mmread in module scipy.io.mmio

mmread(source)
    Reads the contents of a Matrix Market file-like 'source' into a matrix.
    
    Parameters
    ----------
    source : str or file-like
        Matrix Market filename (extensions .mtx, .mtz.gz)
        or open file-like object.
    
    Returns
    -------
    a : ndarray or coo_matrix
        Dense or sparse matrix depending on the matrix format in the
        Matrix Market file.
",function,"('source',)","(nan,)","(nan,)","('arg_info',)","('(source)',)"
scipy,1.1.0,scipy.io.mmwrite,io,mmwrite,"Python Library Documentation: function mmwrite in module scipy.io.mmio

mmwrite(target, a, comment='', field=None, precision=None, symmetry=None)
    Writes the sparse or dense array `a` to Matrix Market file-like `target`.
    
    Parameters
    ----------
    target : str or file-like
        Matrix Market filename (extension .mtx) or open file-like object.
    a : array like
        Sparse or dense 2D array.
    comment : str, optional
        Comments to be prepended to the Matrix Market file.
    field : None or str, optional
        Either 'real', 'complex', 'pattern', or 'integer'.
    precision : None or int, optional
        Number of digits to display for real or complex values.
    symmetry : None or str, optional
        Either 'general', 'symmetric', 'skew-symmetric', or 'hermitian'.
        If symmetry is None the symmetry type of 'a' is determined by its
        values.
",function,"(""(target, a, comment='', field=None, precision=None, symmetry=None)"",)",scipy,1.1.0,scipy.io.mmwrite,io,mmwrite,"Python Library Documentation: function mmwrite in module scipy.io.mmio

mmwrite(target, a, comment='', field=None, precision=None, symmetry=None)
    Writes the sparse or dense array `a` to Matrix Market file-like `target`.
    
    Parameters
    ----------
    target : str or file-like
        Matrix Market filename (extension .mtx) or open file-like object.
    a : array like
        Sparse or dense 2D array.
    comment : str, optional
        Comments to be prepended to the Matrix Market file.
    field : None or str, optional
        Either 'real', 'complex', 'pattern', or 'integer'.
    precision : None or int, optional
        Number of digits to display for real or complex values.
    symmetry : None or str, optional
        Either 'general', 'symmetric', 'skew-symmetric', or 'hermitian'.
        If symmetry is None the symmetry type of 'a' is determined by its
        values.
",function,"('target', 'a', 'comment', 'field', 'precision', 'symmetry')","(nan, nan, '', None, None, None)","(nan, nan, nan, 'NoneType', 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(target, a, comment='', field=None, precision=None, symmetry=None)"",)"
scipy,1.1.0,scipy.io.netcdf.NetCDFFile,io.netcdf,netcdf_file,"Python Library Documentation: class netcdf_file in module scipy.io.netcdf

class netcdf_file(builtins.object)
 |  A file object for NetCDF data.
 |  
 |  A `netcdf_file` object has two standard attributes: `dimensions` and
 |  `variables`. The values of both are dictionaries, mapping dimension
 |  names to their associated lengths and variable names to variables,
 |  respectively. Application programs should never modify these
 |  dictionaries.
 |  
 |  All other attributes correspond to global attributes defined in the
 |  NetCDF file. Global file attributes are created by assigning to an
 |  attribute of the `netcdf_file` object.
 |  
 |  Parameters
 |  ----------
 |  filename : string or file-like
 |      string -> filename
 |  mode : {'r', 'w', 'a'}, optional
 |      read-write-append mode, default is 'r'
 |  mmap : None or bool, optional
 |      Whether to mmap `filename` when reading.  Default is True
 |      when `filename` is a file name, False when `filename` is a
 |      file-like object. Note that when mmap is in use, data arrays
 |      returned refer directly to the mmapped data on disk, and the
 |      file cannot be closed as long as references to it exist.
 |  version : {1, 2}, optional
 |      version of netcdf to read / write, where 1 means *Classic
 |      format* and 2 means *64-bit offset format*.  Default is 1.  See
 |      `here <https://www.unidata.ucar.edu/software/netcdf/docs/netcdf_introduction.html#select_format>`__
 |      for more info.
 |  maskandscale : bool, optional
 |      Whether to automatically scale and/or mask data based on attributes.
 |      Default is False.
 |  
 |  Notes
 |  -----
 |  The major advantage of this module over other modules is that it doesn't
 |  require the code to be linked to the NetCDF libraries. This module is
 |  derived from `pupynere <https://bitbucket.org/robertodealmeida/pupynere/>`_.
 |  
 |  NetCDF files are a self-describing binary data format. The file contains
 |  metadata that describes the dimensions and variables in the file. More
 |  details about NetCDF files can be found `here
 |  <https://www.unidata.ucar.edu/software/netcdf/docs/user_guide.html>`__. There
 |  are three main sections to a NetCDF data structure:
 |  
 |  1. Dimensions
 |  2. Variables
 |  3. Attributes
 |  
 |  The dimensions section records the name and length of each dimension used
 |  by the variables. The variables would then indicate which dimensions it
 |  uses and any attributes such as data units, along with containing the data
 |  values for the variable. It is good practice to include a
 |  variable that is the same name as a dimension to provide the values for
 |  that axes. Lastly, the attributes section would contain additional
 |  information such as the name of the file creator or the instrument used to
 |  collect the data.
 |  
 |  When writing data to a NetCDF file, there is often the need to indicate the
 |  'record dimension'. A record dimension is the unbounded dimension for a
 |  variable. For example, a temperature variable may have dimensions of
 |  latitude, longitude and time. If one wants to add more temperature data to
 |  the NetCDF file as time progresses, then the temperature variable should
 |  have the time dimension flagged as the record dimension.
 |  
 |  In addition, the NetCDF file header contains the position of the data in
 |  the file, so access can be done in an efficient manner without loading
 |  unnecessary data into memory. It uses the ``mmap`` module to create
 |  Numpy arrays mapped to the data on disk, for the same purpose.
 |  
 |  Note that when `netcdf_file` is used to open a file with mmap=True
 |  (default for read-only), arrays returned by it refer to data
 |  directly on the disk. The file should not be closed, and cannot be cleanly
 |  closed when asked, if such arrays are alive. You may want to copy data arrays
 |  obtained from mmapped Netcdf file if they are to be processed after the file
 |  is closed, see the example below.
 |  
 |  Examples
 |  --------
 |  To create a NetCDF file:
 |  
 |  >>> from scipy.io import netcdf
 |  >>> f = netcdf.netcdf_file('simple.nc', 'w')
 |  >>> f.history = 'Created for a test'
 |  >>> f.createDimension('time', 10)
 |  >>> time = f.createVariable('time', 'i', ('time',))
 |  >>> time[:] = np.arange(10)
 |  >>> time.units = 'days since 2008-01-01'
 |  >>> f.close()
 |  
 |  Note the assignment of ``arange(10)`` to ``time[:]``.  Exposing the slice
 |  of the time variable allows for the data to be set in the object, rather
 |  than letting ``arange(10)`` overwrite the ``time`` variable.
 |  
 |  To read the NetCDF file we just created:
 |  
 |  >>> from scipy.io import netcdf
 |  >>> f = netcdf.netcdf_file('simple.nc', 'r')
 |  >>> print(f.history)
 |  b'Created for a test'
 |  >>> time = f.variables['time']
 |  >>> print(time.units)
 |  b'days since 2008-01-01'
 |  >>> print(time.shape)
 |  (10,)
 |  >>> print(time[-1])
 |  9
 |  
 |  NetCDF files, when opened read-only, return arrays that refer
 |  directly to memory-mapped data on disk:
 |  
 |  >>> data = time[:]
 |  >>> data.base.base
 |  <mmap.mmap object at 0x7fe753763180>
 |  
 |  If the data is to be processed after the file is closed, it needs
 |  to be copied to main memory:
 |  
 |  >>> data = time[:].copy()
 |  >>> f.close()
 |  >>> data.mean()
 |  4.5
 |  
 |  A NetCDF file can also be used as context manager:
 |  
 |  >>> from scipy.io import netcdf
 |  >>> with netcdf.netcdf_file('simple.nc', 'r') as f:
 |  ...     print(f.history)
 |  b'Created for a test'
 |  
 |  Methods defined here:
 |  
 |  __del__ = close(self)
 |  
 |  __enter__(self)
 |  
 |  __exit__(self, type, value, traceback)
 |  
 |  __init__(self, filename, mode='r', mmap=None, version=1, maskandscale=False)
 |      Initialize netcdf_file from fileobj (str or file-like).
 |  
 |  __setattr__(self, attr, value)
 |      Implement setattr(self, name, value).
 |  
 |  close(self)
 |      Closes the NetCDF file.
 |  
 |  createDimension(self, name, length)
 |      Adds a dimension to the Dimension section of the NetCDF data structure.
 |      
 |      Note that this function merely adds a new dimension that the variables can
 |      reference.  The values for the dimension, if desired, should be added as
 |      a variable using `createVariable`, referring to this dimension.
 |      
 |      Parameters
 |      ----------
 |      name : str
 |          Name of the dimension (Eg, 'lat' or 'time').
 |      length : int
 |          Length of the dimension.
 |      
 |      See Also
 |      --------
 |      createVariable
 |  
 |  createVariable(self, name, type, dimensions)
 |      Create an empty variable for the `netcdf_file` object, specifying its data
 |      type and the dimensions it uses.
 |      
 |      Parameters
 |      ----------
 |      name : str
 |          Name of the new variable.
 |      type : dtype or str
 |          Data type of the variable.
 |      dimensions : sequence of str
 |          List of the dimension names used by the variable, in the desired order.
 |      
 |      Returns
 |      -------
 |      variable : netcdf_variable
 |          The newly created ``netcdf_variable`` object.
 |          This object has also been added to the `netcdf_file` object as well.
 |      
 |      See Also
 |      --------
 |      createDimension
 |      
 |      Notes
 |      -----
 |      Any dimensions to be used by the variable should already exist in the
 |      NetCDF data structure or should be created by `createDimension` prior to
 |      creating the NetCDF variable.
 |  
 |  flush(self)
 |      Perform a sync-to-disk flush if the `netcdf_file` object is in write mode.
 |      
 |      See Also
 |      --------
 |      sync : Identical function
 |  
 |  sync = flush(self)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"(""(self, filename, mode='r', mmap=None, version=1, maskandscale=False)"",)",scipy,1.1.0,scipy.io.netcdf.NetCDFFile,io.netcdf,netcdf_file,"Python Library Documentation: class netcdf_file in module scipy.io.netcdf

class netcdf_file(builtins.object)
 |  A file object for NetCDF data.
 |  
 |  A `netcdf_file` object has two standard attributes: `dimensions` and
 |  `variables`. The values of both are dictionaries, mapping dimension
 |  names to their associated lengths and variable names to variables,
 |  respectively. Application programs should never modify these
 |  dictionaries.
 |  
 |  All other attributes correspond to global attributes defined in the
 |  NetCDF file. Global file attributes are created by assigning to an
 |  attribute of the `netcdf_file` object.
 |  
 |  Parameters
 |  ----------
 |  filename : string or file-like
 |      string -> filename
 |  mode : {'r', 'w', 'a'}, optional
 |      read-write-append mode, default is 'r'
 |  mmap : None or bool, optional
 |      Whether to mmap `filename` when reading.  Default is True
 |      when `filename` is a file name, False when `filename` is a
 |      file-like object. Note that when mmap is in use, data arrays
 |      returned refer directly to the mmapped data on disk, and the
 |      file cannot be closed as long as references to it exist.
 |  version : {1, 2}, optional
 |      version of netcdf to read / write, where 1 means *Classic
 |      format* and 2 means *64-bit offset format*.  Default is 1.  See
 |      `here <https://www.unidata.ucar.edu/software/netcdf/docs/netcdf_introduction.html#select_format>`__
 |      for more info.
 |  maskandscale : bool, optional
 |      Whether to automatically scale and/or mask data based on attributes.
 |      Default is False.
 |  
 |  Notes
 |  -----
 |  The major advantage of this module over other modules is that it doesn't
 |  require the code to be linked to the NetCDF libraries. This module is
 |  derived from `pupynere <https://bitbucket.org/robertodealmeida/pupynere/>`_.
 |  
 |  NetCDF files are a self-describing binary data format. The file contains
 |  metadata that describes the dimensions and variables in the file. More
 |  details about NetCDF files can be found `here
 |  <https://www.unidata.ucar.edu/software/netcdf/docs/user_guide.html>`__. There
 |  are three main sections to a NetCDF data structure:
 |  
 |  1. Dimensions
 |  2. Variables
 |  3. Attributes
 |  
 |  The dimensions section records the name and length of each dimension used
 |  by the variables. The variables would then indicate which dimensions it
 |  uses and any attributes such as data units, along with containing the data
 |  values for the variable. It is good practice to include a
 |  variable that is the same name as a dimension to provide the values for
 |  that axes. Lastly, the attributes section would contain additional
 |  information such as the name of the file creator or the instrument used to
 |  collect the data.
 |  
 |  When writing data to a NetCDF file, there is often the need to indicate the
 |  'record dimension'. A record dimension is the unbounded dimension for a
 |  variable. For example, a temperature variable may have dimensions of
 |  latitude, longitude and time. If one wants to add more temperature data to
 |  the NetCDF file as time progresses, then the temperature variable should
 |  have the time dimension flagged as the record dimension.
 |  
 |  In addition, the NetCDF file header contains the position of the data in
 |  the file, so access can be done in an efficient manner without loading
 |  unnecessary data into memory. It uses the ``mmap`` module to create
 |  Numpy arrays mapped to the data on disk, for the same purpose.
 |  
 |  Note that when `netcdf_file` is used to open a file with mmap=True
 |  (default for read-only), arrays returned by it refer to data
 |  directly on the disk. The file should not be closed, and cannot be cleanly
 |  closed when asked, if such arrays are alive. You may want to copy data arrays
 |  obtained from mmapped Netcdf file if they are to be processed after the file
 |  is closed, see the example below.
 |  
 |  Examples
 |  --------
 |  To create a NetCDF file:
 |  
 |  >>> from scipy.io import netcdf
 |  >>> f = netcdf.netcdf_file('simple.nc', 'w')
 |  >>> f.history = 'Created for a test'
 |  >>> f.createDimension('time', 10)
 |  >>> time = f.createVariable('time', 'i', ('time',))
 |  >>> time[:] = np.arange(10)
 |  >>> time.units = 'days since 2008-01-01'
 |  >>> f.close()
 |  
 |  Note the assignment of ``arange(10)`` to ``time[:]``.  Exposing the slice
 |  of the time variable allows for the data to be set in the object, rather
 |  than letting ``arange(10)`` overwrite the ``time`` variable.
 |  
 |  To read the NetCDF file we just created:
 |  
 |  >>> from scipy.io import netcdf
 |  >>> f = netcdf.netcdf_file('simple.nc', 'r')
 |  >>> print(f.history)
 |  b'Created for a test'
 |  >>> time = f.variables['time']
 |  >>> print(time.units)
 |  b'days since 2008-01-01'
 |  >>> print(time.shape)
 |  (10,)
 |  >>> print(time[-1])
 |  9
 |  
 |  NetCDF files, when opened read-only, return arrays that refer
 |  directly to memory-mapped data on disk:
 |  
 |  >>> data = time[:]
 |  >>> data.base.base
 |  <mmap.mmap object at 0x7fe753763180>
 |  
 |  If the data is to be processed after the file is closed, it needs
 |  to be copied to main memory:
 |  
 |  >>> data = time[:].copy()
 |  >>> f.close()
 |  >>> data.mean()
 |  4.5
 |  
 |  A NetCDF file can also be used as context manager:
 |  
 |  >>> from scipy.io import netcdf
 |  >>> with netcdf.netcdf_file('simple.nc', 'r') as f:
 |  ...     print(f.history)
 |  b'Created for a test'
 |  
 |  Methods defined here:
 |  
 |  __del__ = close(self)
 |  
 |  __enter__(self)
 |  
 |  __exit__(self, type, value, traceback)
 |  
 |  __init__(self, filename, mode='r', mmap=None, version=1, maskandscale=False)
 |      Initialize netcdf_file from fileobj (str or file-like).
 |  
 |  __setattr__(self, attr, value)
 |      Implement setattr(self, name, value).
 |  
 |  close(self)
 |      Closes the NetCDF file.
 |  
 |  createDimension(self, name, length)
 |      Adds a dimension to the Dimension section of the NetCDF data structure.
 |      
 |      Note that this function merely adds a new dimension that the variables can
 |      reference.  The values for the dimension, if desired, should be added as
 |      a variable using `createVariable`, referring to this dimension.
 |      
 |      Parameters
 |      ----------
 |      name : str
 |          Name of the dimension (Eg, 'lat' or 'time').
 |      length : int
 |          Length of the dimension.
 |      
 |      See Also
 |      --------
 |      createVariable
 |  
 |  createVariable(self, name, type, dimensions)
 |      Create an empty variable for the `netcdf_file` object, specifying its data
 |      type and the dimensions it uses.
 |      
 |      Parameters
 |      ----------
 |      name : str
 |          Name of the new variable.
 |      type : dtype or str
 |          Data type of the variable.
 |      dimensions : sequence of str
 |          List of the dimension names used by the variable, in the desired order.
 |      
 |      Returns
 |      -------
 |      variable : netcdf_variable
 |          The newly created ``netcdf_variable`` object.
 |          This object has also been added to the `netcdf_file` object as well.
 |      
 |      See Also
 |      --------
 |      createDimension
 |      
 |      Notes
 |      -----
 |      Any dimensions to be used by the variable should already exist in the
 |      NetCDF data structure or should be created by `createDimension` prior to
 |      creating the NetCDF variable.
 |  
 |  flush(self)
 |      Perform a sync-to-disk flush if the `netcdf_file` object is in write mode.
 |      
 |      See Also
 |      --------
 |      sync : Identical function
 |  
 |  sync = flush(self)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'filename', 'mode', 'mmap', 'version', 'maskandscale')","(nan, nan, 'r', None, 1, False)","(nan, nan, 'str', 'NoneType', 'int', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(self, filename, mode='r', mmap=None, version=1, maskandscale=False)"",)"
scipy,1.1.0,scipy.io.netcdf.NetCDFVariable,io.netcdf,netcdf_variable,"Python Library Documentation: class netcdf_variable in module scipy.io.netcdf

class netcdf_variable(builtins.object)
 |  A data object for the `netcdf` module.
 |  
 |  `netcdf_variable` objects are constructed by calling the method
 |  `netcdf_file.createVariable` on the `netcdf_file` object. `netcdf_variable`
 |  objects behave much like array objects defined in numpy, except that their
 |  data resides in a file. Data is read by indexing and written by assigning
 |  to an indexed subset; the entire array can be accessed by the index ``[:]``
 |  or (for scalars) by using the methods `getValue` and `assignValue`.
 |  `netcdf_variable` objects also have attribute `shape` with the same meaning
 |  as for arrays, but the shape cannot be modified. There is another read-only
 |  attribute `dimensions`, whose value is the tuple of dimension names.
 |  
 |  All other attributes correspond to variable attributes defined in
 |  the NetCDF file. Variable attributes are created by assigning to an
 |  attribute of the `netcdf_variable` object.
 |  
 |  Parameters
 |  ----------
 |  data : array_like
 |      The data array that holds the values for the variable.
 |      Typically, this is initialized as empty, but with the proper shape.
 |  typecode : dtype character code
 |      Desired data-type for the data array.
 |  size : int
 |      Desired element size for the data array.
 |  shape : sequence of ints
 |      The shape of the array.  This should match the lengths of the
 |      variable's dimensions.
 |  dimensions : sequence of strings
 |      The names of the dimensions used by the variable.  Must be in the
 |      same order of the dimension lengths given by `shape`.
 |  attributes : dict, optional
 |      Attribute values (any type) keyed by string names.  These attributes
 |      become attributes for the netcdf_variable object.
 |  maskandscale : bool, optional
 |      Whether to automatically scale and/or mask data based on attributes.
 |      Default is False.
 |  
 |  
 |  Attributes
 |  ----------
 |  dimensions : list of str
 |      List of names of dimensions used by the variable object.
 |  isrec, shape
 |      Properties
 |  
 |  See also
 |  --------
 |  isrec, shape
 |  
 |  Methods defined here:
 |  
 |  __getitem__(self, index)
 |  
 |  __init__(self, data, typecode, size, shape, dimensions, attributes=None, maskandscale=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __setattr__(self, attr, value)
 |      Implement setattr(self, name, value).
 |  
 |  __setitem__(self, index, data)
 |  
 |  assignValue(self, value)
 |      Assign a scalar value to a `netcdf_variable` of length one.
 |      
 |      Parameters
 |      ----------
 |      value : scalar
 |          Scalar value (of compatible type) to assign to a length-one netcdf
 |          variable. This value will be written to file.
 |      
 |      Raises
 |      ------
 |      ValueError
 |          If the input is not a scalar, or if the destination is not a length-one
 |          netcdf variable.
 |  
 |  getValue(self)
 |      Retrieve a scalar value from a `netcdf_variable` of length one.
 |      
 |      Raises
 |      ------
 |      ValueError
 |          If the netcdf variable is an array of length greater than one,
 |          this exception will be raised.
 |  
 |  itemsize(self)
 |      Return the itemsize of the variable.
 |      
 |      Returns
 |      -------
 |      itemsize : int
 |          The element size of the variable (eg, 8 for float64).
 |  
 |  typecode(self)
 |      Return the typecode of the variable.
 |      
 |      Returns
 |      -------
 |      typecode : char
 |          The character typecode of the variable (eg, 'i' for int).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  isrec
 |      Returns whether the variable has a record dimension or not.
 |      
 |      A record dimension is a dimension along which additional data could be
 |      easily appended in the netcdf data structure without much rewriting of
 |      the data file. This attribute is a read-only property of the
 |      `netcdf_variable`.
 |  
 |  shape
 |      Returns the shape tuple of the data variable.
 |      
 |      This is a read-only attribute and can not be modified in the
 |      same manner of other numpy arrays.
",class,"('(self, data, typecode, size, shape, dimensions, attributes=None, maskandscale=False)',)",scipy,1.1.0,scipy.io.netcdf.NetCDFVariable,io.netcdf,netcdf_variable,"Python Library Documentation: class netcdf_variable in module scipy.io.netcdf

class netcdf_variable(builtins.object)
 |  A data object for the `netcdf` module.
 |  
 |  `netcdf_variable` objects are constructed by calling the method
 |  `netcdf_file.createVariable` on the `netcdf_file` object. `netcdf_variable`
 |  objects behave much like array objects defined in numpy, except that their
 |  data resides in a file. Data is read by indexing and written by assigning
 |  to an indexed subset; the entire array can be accessed by the index ``[:]``
 |  or (for scalars) by using the methods `getValue` and `assignValue`.
 |  `netcdf_variable` objects also have attribute `shape` with the same meaning
 |  as for arrays, but the shape cannot be modified. There is another read-only
 |  attribute `dimensions`, whose value is the tuple of dimension names.
 |  
 |  All other attributes correspond to variable attributes defined in
 |  the NetCDF file. Variable attributes are created by assigning to an
 |  attribute of the `netcdf_variable` object.
 |  
 |  Parameters
 |  ----------
 |  data : array_like
 |      The data array that holds the values for the variable.
 |      Typically, this is initialized as empty, but with the proper shape.
 |  typecode : dtype character code
 |      Desired data-type for the data array.
 |  size : int
 |      Desired element size for the data array.
 |  shape : sequence of ints
 |      The shape of the array.  This should match the lengths of the
 |      variable's dimensions.
 |  dimensions : sequence of strings
 |      The names of the dimensions used by the variable.  Must be in the
 |      same order of the dimension lengths given by `shape`.
 |  attributes : dict, optional
 |      Attribute values (any type) keyed by string names.  These attributes
 |      become attributes for the netcdf_variable object.
 |  maskandscale : bool, optional
 |      Whether to automatically scale and/or mask data based on attributes.
 |      Default is False.
 |  
 |  
 |  Attributes
 |  ----------
 |  dimensions : list of str
 |      List of names of dimensions used by the variable object.
 |  isrec, shape
 |      Properties
 |  
 |  See also
 |  --------
 |  isrec, shape
 |  
 |  Methods defined here:
 |  
 |  __getitem__(self, index)
 |  
 |  __init__(self, data, typecode, size, shape, dimensions, attributes=None, maskandscale=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __setattr__(self, attr, value)
 |      Implement setattr(self, name, value).
 |  
 |  __setitem__(self, index, data)
 |  
 |  assignValue(self, value)
 |      Assign a scalar value to a `netcdf_variable` of length one.
 |      
 |      Parameters
 |      ----------
 |      value : scalar
 |          Scalar value (of compatible type) to assign to a length-one netcdf
 |          variable. This value will be written to file.
 |      
 |      Raises
 |      ------
 |      ValueError
 |          If the input is not a scalar, or if the destination is not a length-one
 |          netcdf variable.
 |  
 |  getValue(self)
 |      Retrieve a scalar value from a `netcdf_variable` of length one.
 |      
 |      Raises
 |      ------
 |      ValueError
 |          If the netcdf variable is an array of length greater than one,
 |          this exception will be raised.
 |  
 |  itemsize(self)
 |      Return the itemsize of the variable.
 |      
 |      Returns
 |      -------
 |      itemsize : int
 |          The element size of the variable (eg, 8 for float64).
 |  
 |  typecode(self)
 |      Return the typecode of the variable.
 |      
 |      Returns
 |      -------
 |      typecode : char
 |          The character typecode of the variable (eg, 'i' for int).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  isrec
 |      Returns whether the variable has a record dimension or not.
 |      
 |      A record dimension is a dimension along which additional data could be
 |      easily appended in the netcdf data structure without much rewriting of
 |      the data file. This attribute is a read-only property of the
 |      `netcdf_variable`.
 |  
 |  shape
 |      Returns the shape tuple of the data variable.
 |      
 |      This is a read-only attribute and can not be modified in the
 |      same manner of other numpy arrays.
",class,"('self', 'data', 'typecode', 'size', 'shape', 'dimensions', 'attributes', 'maskandscale')","(nan, nan, nan, nan, nan, nan, None, False)","(nan, nan, nan, nan, nan, nan, 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, data, typecode, size, shape, dimensions, attributes=None, maskandscale=False)',)"
scipy,1.1.0,scipy.io.netcdf.OrderedDict,io.netcdf,OrderedDict,"Python Library Documentation: class OrderedDict in module collections

class OrderedDict(builtins.dict)
 |  Dictionary that remembers insertion order
 |  
 |  Method resolution order:
 |      OrderedDict
 |      builtins.dict
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      Return state information for pickling
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(...)
 |      od.__reversed__() <==> reversed(od)
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __sizeof__(...)
 |      D.__sizeof__() -> size of D in memory, in bytes
 |  
 |  clear(...)
 |      od.clear() -> None.  Remove all items from od.
 |  
 |  copy(...)
 |      od.copy() -> a shallow copy of od
 |  
 |  fromkeys(...) from builtins.type
 |      OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S.
 |      If not specified, the value defaults to None.
 |  
 |  items(...)
 |      D.items() -> a set-like object providing a view on D's items
 |  
 |  keys(...)
 |      D.keys() -> a set-like object providing a view on D's keys
 |  
 |  move_to_end(...)
 |      Move an existing element to the end (or beginning if last==False).
 |      
 |      Raises KeyError if the element does not exist.
 |      When last=True, acts like a fast version of self[key]=self.pop(key).
 |  
 |  pop(...)
 |      od.pop(k[,d]) -> v, remove specified key and return the corresponding
 |      value.  If key is not found, d is returned if given, otherwise KeyError
 |      is raised.
 |  
 |  popitem(self, /, last=True)
 |      Remove and return a (key, value) pair from the dictionary.
 |      
 |      Pairs are returned in LIFO order if last is true or FIFO order if false.
 |  
 |  setdefault(...)
 |      od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od
 |  
 |  update(...)
 |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
 |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
 |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
 |      In either case, this is followed by: for k in F:  D[k] = F[k]
 |  
 |  values(...)
 |      D.values() -> an object providing a view on D's values
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.dict:
 |  
 |  __contains__(self, key, /)
 |      True if D has a key k, else False.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  get(...)
 |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.netcdf.OrderedDict,io.netcdf,OrderedDict,"Python Library Documentation: class OrderedDict in module collections

class OrderedDict(builtins.dict)
 |  Dictionary that remembers insertion order
 |  
 |  Method resolution order:
 |      OrderedDict
 |      builtins.dict
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      Return state information for pickling
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(...)
 |      od.__reversed__() <==> reversed(od)
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __sizeof__(...)
 |      D.__sizeof__() -> size of D in memory, in bytes
 |  
 |  clear(...)
 |      od.clear() -> None.  Remove all items from od.
 |  
 |  copy(...)
 |      od.copy() -> a shallow copy of od
 |  
 |  fromkeys(...) from builtins.type
 |      OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S.
 |      If not specified, the value defaults to None.
 |  
 |  items(...)
 |      D.items() -> a set-like object providing a view on D's items
 |  
 |  keys(...)
 |      D.keys() -> a set-like object providing a view on D's keys
 |  
 |  move_to_end(...)
 |      Move an existing element to the end (or beginning if last==False).
 |      
 |      Raises KeyError if the element does not exist.
 |      When last=True, acts like a fast version of self[key]=self.pop(key).
 |  
 |  pop(...)
 |      od.pop(k[,d]) -> v, remove specified key and return the corresponding
 |      value.  If key is not found, d is returned if given, otherwise KeyError
 |      is raised.
 |  
 |  popitem(self, /, last=True)
 |      Remove and return a (key, value) pair from the dictionary.
 |      
 |      Pairs are returned in LIFO order if last is true or FIFO order if false.
 |  
 |  setdefault(...)
 |      od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od
 |  
 |  update(...)
 |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
 |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
 |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
 |      In either case, this is followed by: for k in F:  D[k] = F[k]
 |  
 |  values(...)
 |      D.values() -> an object providing a view on D's values
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.dict:
 |  
 |  __contains__(self, key, /)
 |      True if D has a key k, else False.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  get(...)
 |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.netcdf.asarray,io.netcdf,asarray,"Python Library Documentation: function asarray in module numpy.core.numeric

asarray(a, dtype=None, order=None)
    Convert the input to an array.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
        Whether to use row-major (C-style) or
        column-major (Fortran-style) memory representation.
        Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray with matching dtype and order.  If `a` is a
        subclass of ndarray, a base class ndarray is returned.
    
    See Also
    --------
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    asarray_chkfinite : Similar function which checks input for NaNs and Infs.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array:
    
    >>> a = [1, 2]
    >>> np.asarray(a)
    array([1, 2])
    
    Existing arrays are not copied:
    
    >>> a = np.array([1, 2])
    >>> np.asarray(a) is a
    True
    
    If `dtype` is set, array is copied only if dtype does not match:
    
    >>> a = np.array([1, 2], dtype=np.float32)
    >>> np.asarray(a, dtype=np.float32) is a
    True
    >>> np.asarray(a, dtype=np.float64) is a
    False
    
    Contrary to `asanyarray`, ndarray subclasses are not passed through:
    
    >>> issubclass(np.matrix, np.ndarray)
    True
    >>> a = np.matrix([[1, 2]])
    >>> np.asarray(a) is a
    False
    >>> np.asanyarray(a) is a
    True
",function,"('(a, dtype=None, order=None)',)",scipy,1.1.0,scipy.io.netcdf.asarray,io.netcdf,asarray,"Python Library Documentation: function asarray in module numpy.core.numeric

asarray(a, dtype=None, order=None)
    Convert the input to an array.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
        Whether to use row-major (C-style) or
        column-major (Fortran-style) memory representation.
        Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray with matching dtype and order.  If `a` is a
        subclass of ndarray, a base class ndarray is returned.
    
    See Also
    --------
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    asarray_chkfinite : Similar function which checks input for NaNs and Infs.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array:
    
    >>> a = [1, 2]
    >>> np.asarray(a)
    array([1, 2])
    
    Existing arrays are not copied:
    
    >>> a = np.array([1, 2])
    >>> np.asarray(a) is a
    True
    
    If `dtype` is set, array is copied only if dtype does not match:
    
    >>> a = np.array([1, 2], dtype=np.float32)
    >>> np.asarray(a, dtype=np.float32) is a
    True
    >>> np.asarray(a, dtype=np.float64) is a
    False
    
    Contrary to `asanyarray`, ndarray subclasses are not passed through:
    
    >>> issubclass(np.matrix, np.ndarray)
    True
    >>> a = np.matrix([[1, 2]])
    >>> np.asarray(a) is a
    False
    >>> np.asanyarray(a) is a
    True
",function,"('a', 'dtype', 'order')","(nan, None, None)","(nan, 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(a, dtype=None, order=None)',)"
scipy,1.1.0,scipy.io.netcdf.asbytes,io.netcdf,asbytes,"Python Library Documentation: function asbytes in module numpy.compat.py3k

asbytes(s)
",function,"('(s)',)",scipy,1.1.0,scipy.io.netcdf.asbytes,io.netcdf,asbytes,"Python Library Documentation: function asbytes in module numpy.compat.py3k

asbytes(s)
",function,"('s',)","(nan,)","(nan,)","('arg_info',)","('(s)',)"
scipy,1.1.0,scipy.io.netcdf.asstr,io.netcdf,asstr,"Python Library Documentation: function asstr in module numpy.compat.py3k

asstr(s)
",function,"('(s)',)",scipy,1.1.0,scipy.io.netcdf.asstr,io.netcdf,asstr,"Python Library Documentation: function asstr in module numpy.compat.py3k

asstr(s)
",function,"('s',)","(nan,)","(nan,)","('arg_info',)","('(s)',)"
scipy,1.1.0,scipy.io.netcdf.binary_type,io.netcdf,bytes,"Python Library Documentation: class bytes in module builtins

class bytes(object)
 |  bytes(iterable_of_ints) -> bytes
 |  bytes(string, encoding[, errors]) -> bytes
 |  bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer
 |  bytes(int) -> bytes object of size given by the parameter initialized with null bytes
 |  bytes() -> empty bytes object
 |  
 |  Construct an immutable array of bytes from:
 |    - an iterable yielding integers in range(256)
 |    - a text string encoded using the specified encoding
 |    - any object implementing the buffer API.
 |    - an integer
 |  
 |  Methods defined here:
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __getnewargs__(...)
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.n
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return self*value.
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  capitalize(...)
 |      B.capitalize() -> copy of B
 |      
 |      Return a copy of B with only its first character capitalized (ASCII)
 |      and the rest lower-cased.
 |  
 |  center(...)
 |      B.center(width[, fillchar]) -> copy of B
 |      
 |      Return B centered in a string of length width.  Padding is
 |      done using the specified fill character (default is a space).
 |  
 |  count(...)
 |      B.count(sub[, start[, end]]) -> int
 |      
 |      Return the number of non-overlapping occurrences of subsection sub in
 |      bytes B[start:end].  Optional arguments start and end are interpreted
 |      as in slice notation.
 |  
 |  decode(self, /, encoding='utf-8', errors='strict')
 |      Decode the bytes using the codec registered for encoding.
 |      
 |      encoding
 |        The encoding with which to decode the bytes.
 |      errors
 |        The error handling scheme to use for the handling of decoding errors.
 |        The default is 'strict' meaning that decoding errors raise a
 |        UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
 |        as well as any other name registered with codecs.register_error that
 |        can handle UnicodeDecodeErrors.
 |  
 |  endswith(...)
 |      B.endswith(suffix[, start[, end]]) -> bool
 |      
 |      Return True if B ends with the specified suffix, False otherwise.
 |      With optional start, test B beginning at that position.
 |      With optional end, stop comparing B at that position.
 |      suffix can also be a tuple of bytes to try.
 |  
 |  expandtabs(...)
 |      B.expandtabs(tabsize=8) -> copy of B
 |      
 |      Return a copy of B where all tab characters are expanded using spaces.
 |      If tabsize is not given, a tab size of 8 characters is assumed.
 |  
 |  find(...)
 |      B.find(sub[, start[, end]]) -> int
 |      
 |      Return the lowest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Return -1 on failure.
 |  
 |  fromhex(string, /) from builtins.type
 |      Create a bytes object from a string of hexadecimal numbers.
 |      
 |      Spaces between two numbers are accepted.
 |      Example: bytes.fromhex('B9 01EF') -> b'\\xb9\\x01\\xef'.
 |  
 |  hex(...)
 |      B.hex() -> string
 |      
 |      Create a string of hexadecimal numbers from a bytes object.
 |      Example: b'\xb9\x01\xef'.hex() -> 'b901ef'.
 |  
 |  index(...)
 |      B.index(sub[, start[, end]]) -> int
 |      
 |      Return the lowest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Raises ValueError when the subsection is not found.
 |  
 |  isalnum(...)
 |      B.isalnum() -> bool
 |      
 |      Return True if all characters in B are alphanumeric
 |      and there is at least one character in B, False otherwise.
 |  
 |  isalpha(...)
 |      B.isalpha() -> bool
 |      
 |      Return True if all characters in B are alphabetic
 |      and there is at least one character in B, False otherwise.
 |  
 |  isdigit(...)
 |      B.isdigit() -> bool
 |      
 |      Return True if all characters in B are digits
 |      and there is at least one character in B, False otherwise.
 |  
 |  islower(...)
 |      B.islower() -> bool
 |      
 |      Return True if all cased characters in B are lowercase and there is
 |      at least one cased character in B, False otherwise.
 |  
 |  isspace(...)
 |      B.isspace() -> bool
 |      
 |      Return True if all characters in B are whitespace
 |      and there is at least one character in B, False otherwise.
 |  
 |  istitle(...)
 |      B.istitle() -> bool
 |      
 |      Return True if B is a titlecased string and there is at least one
 |      character in B, i.e. uppercase characters may only follow uncased
 |      characters and lowercase characters only cased ones. Return False
 |      otherwise.
 |  
 |  isupper(...)
 |      B.isupper() -> bool
 |      
 |      Return True if all cased characters in B are uppercase and there is
 |      at least one cased character in B, False otherwise.
 |  
 |  join(self, iterable_of_bytes, /)
 |      Concatenate any number of bytes objects.
 |      
 |      The bytes whose method is called is inserted in between each pair.
 |      
 |      The result is returned as a new bytes object.
 |      
 |      Example: b'.'.join([b'ab', b'pq', b'rs']) -> b'ab.pq.rs'.
 |  
 |  ljust(...)
 |      B.ljust(width[, fillchar]) -> copy of B
 |      
 |      Return B left justified in a string of length width. Padding is
 |      done using the specified fill character (default is a space).
 |  
 |  lower(...)
 |      B.lower() -> copy of B
 |      
 |      Return a copy of B with all ASCII characters converted to lowercase.
 |  
 |  lstrip(self, bytes=None, /)
 |      Strip leading bytes contained in the argument.
 |      
 |      If the argument is omitted or None, strip leading  ASCII whitespace.
 |  
 |  partition(self, sep, /)
 |      Partition the bytes into three parts using the given separator.
 |      
 |      This will search for the separator sep in the bytes. If the separator is found,
 |      returns a 3-tuple containing the part before the separator, the separator
 |      itself, and the part after it.
 |      
 |      If the separator is not found, returns a 3-tuple containing the original bytes
 |      object and two empty bytes objects.
 |  
 |  replace(self, old, new, count=-1, /)
 |      Return a copy with all occurrences of substring old replaced by new.
 |      
 |        count
 |          Maximum number of occurrences to replace.
 |          -1 (the default value) means replace all occurrences.
 |      
 |      If the optional argument count is given, only the first count occurrences are
 |      replaced.
 |  
 |  rfind(...)
 |      B.rfind(sub[, start[, end]]) -> int
 |      
 |      Return the highest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Return -1 on failure.
 |  
 |  rindex(...)
 |      B.rindex(sub[, start[, end]]) -> int
 |      
 |      Return the highest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Raise ValueError when the subsection is not found.
 |  
 |  rjust(...)
 |      B.rjust(width[, fillchar]) -> copy of B
 |      
 |      Return B right justified in a string of length width. Padding is
 |      done using the specified fill character (default is a space)
 |  
 |  rpartition(self, sep, /)
 |      Partition the bytes into three parts using the given separator.
 |      
 |      This will search for the separator sep in the bytes, starting at the end. If
 |      the separator is found, returns a 3-tuple containing the part before the
 |      separator, the separator itself, and the part after it.
 |      
 |      If the separator is not found, returns a 3-tuple containing two empty bytes
 |      objects and the original bytes object.
 |  
 |  rsplit(self, /, sep=None, maxsplit=-1)
 |      Return a list of the sections in the bytes, using sep as the delimiter.
 |      
 |        sep
 |          The delimiter according which to split the bytes.
 |          None (the default value) means split on ASCII whitespace characters
 |          (space, tab, return, newline, formfeed, vertical tab).
 |        maxsplit
 |          Maximum number of splits to do.
 |          -1 (the default value) means no limit.
 |      
 |      Splitting is done starting at the end of the bytes and working to the front.
 |  
 |  rstrip(self, bytes=None, /)
 |      Strip trailing bytes contained in the argument.
 |      
 |      If the argument is omitted or None, strip trailing ASCII whitespace.
 |  
 |  split(self, /, sep=None, maxsplit=-1)
 |      Return a list of the sections in the bytes, using sep as the delimiter.
 |      
 |      sep
 |        The delimiter according which to split the bytes.
 |        None (the default value) means split on ASCII whitespace characters
 |        (space, tab, return, newline, formfeed, vertical tab).
 |      maxsplit
 |        Maximum number of splits to do.
 |        -1 (the default value) means no limit.
 |  
 |  splitlines(self, /, keepends=False)
 |      Return a list of the lines in the bytes, breaking at line boundaries.
 |      
 |      Line breaks are not included in the resulting list unless keepends is given and
 |      true.
 |  
 |  startswith(...)
 |      B.startswith(prefix[, start[, end]]) -> bool
 |      
 |      Return True if B starts with the specified prefix, False otherwise.
 |      With optional start, test B beginning at that position.
 |      With optional end, stop comparing B at that position.
 |      prefix can also be a tuple of bytes to try.
 |  
 |  strip(self, bytes=None, /)
 |      Strip leading and trailing bytes contained in the argument.
 |      
 |      If the argument is omitted or None, strip leading and trailing ASCII whitespace.
 |  
 |  swapcase(...)
 |      B.swapcase() -> copy of B
 |      
 |      Return a copy of B with uppercase ASCII characters converted
 |      to lowercase ASCII and vice versa.
 |  
 |  title(...)
 |      B.title() -> copy of B
 |      
 |      Return a titlecased version of B, i.e. ASCII words start with uppercase
 |      characters, all remaining cased characters have lowercase.
 |  
 |  translate(self, table, /, delete=b'')
 |      Return a copy with each character mapped by the given translation table.
 |      
 |        table
 |          Translation table, which must be a bytes object of length 256.
 |      
 |      All characters occurring in the optional argument delete are removed.
 |      The remaining characters are mapped through the given translation table.
 |  
 |  upper(...)
 |      B.upper() -> copy of B
 |      
 |      Return a copy of B with all ASCII characters converted to uppercase.
 |  
 |  zfill(...)
 |      B.zfill(width) -> copy of B
 |      
 |      Pad a numeric string B with zeros on the left, to fill a field
 |      of the specified width.  B is never truncated.
 |  
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |  
 |  maketrans(frm, to, /)
 |      Return a translation table useable for the bytes or bytearray translate method.
 |      
 |      The returned table will be one where each byte in frm is mapped to the byte at
 |      the same position in to.
 |      
 |      The bytes objects frm and to must be of the same length.
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.netcdf.binary_type,io.netcdf,bytes,"Python Library Documentation: class bytes in module builtins

class bytes(object)
 |  bytes(iterable_of_ints) -> bytes
 |  bytes(string, encoding[, errors]) -> bytes
 |  bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer
 |  bytes(int) -> bytes object of size given by the parameter initialized with null bytes
 |  bytes() -> empty bytes object
 |  
 |  Construct an immutable array of bytes from:
 |    - an iterable yielding integers in range(256)
 |    - a text string encoded using the specified encoding
 |    - any object implementing the buffer API.
 |    - an integer
 |  
 |  Methods defined here:
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __getnewargs__(...)
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.n
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return self*value.
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  capitalize(...)
 |      B.capitalize() -> copy of B
 |      
 |      Return a copy of B with only its first character capitalized (ASCII)
 |      and the rest lower-cased.
 |  
 |  center(...)
 |      B.center(width[, fillchar]) -> copy of B
 |      
 |      Return B centered in a string of length width.  Padding is
 |      done using the specified fill character (default is a space).
 |  
 |  count(...)
 |      B.count(sub[, start[, end]]) -> int
 |      
 |      Return the number of non-overlapping occurrences of subsection sub in
 |      bytes B[start:end].  Optional arguments start and end are interpreted
 |      as in slice notation.
 |  
 |  decode(self, /, encoding='utf-8', errors='strict')
 |      Decode the bytes using the codec registered for encoding.
 |      
 |      encoding
 |        The encoding with which to decode the bytes.
 |      errors
 |        The error handling scheme to use for the handling of decoding errors.
 |        The default is 'strict' meaning that decoding errors raise a
 |        UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
 |        as well as any other name registered with codecs.register_error that
 |        can handle UnicodeDecodeErrors.
 |  
 |  endswith(...)
 |      B.endswith(suffix[, start[, end]]) -> bool
 |      
 |      Return True if B ends with the specified suffix, False otherwise.
 |      With optional start, test B beginning at that position.
 |      With optional end, stop comparing B at that position.
 |      suffix can also be a tuple of bytes to try.
 |  
 |  expandtabs(...)
 |      B.expandtabs(tabsize=8) -> copy of B
 |      
 |      Return a copy of B where all tab characters are expanded using spaces.
 |      If tabsize is not given, a tab size of 8 characters is assumed.
 |  
 |  find(...)
 |      B.find(sub[, start[, end]]) -> int
 |      
 |      Return the lowest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Return -1 on failure.
 |  
 |  fromhex(string, /) from builtins.type
 |      Create a bytes object from a string of hexadecimal numbers.
 |      
 |      Spaces between two numbers are accepted.
 |      Example: bytes.fromhex('B9 01EF') -> b'\\xb9\\x01\\xef'.
 |  
 |  hex(...)
 |      B.hex() -> string
 |      
 |      Create a string of hexadecimal numbers from a bytes object.
 |      Example: b'\xb9\x01\xef'.hex() -> 'b901ef'.
 |  
 |  index(...)
 |      B.index(sub[, start[, end]]) -> int
 |      
 |      Return the lowest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Raises ValueError when the subsection is not found.
 |  
 |  isalnum(...)
 |      B.isalnum() -> bool
 |      
 |      Return True if all characters in B are alphanumeric
 |      and there is at least one character in B, False otherwise.
 |  
 |  isalpha(...)
 |      B.isalpha() -> bool
 |      
 |      Return True if all characters in B are alphabetic
 |      and there is at least one character in B, False otherwise.
 |  
 |  isdigit(...)
 |      B.isdigit() -> bool
 |      
 |      Return True if all characters in B are digits
 |      and there is at least one character in B, False otherwise.
 |  
 |  islower(...)
 |      B.islower() -> bool
 |      
 |      Return True if all cased characters in B are lowercase and there is
 |      at least one cased character in B, False otherwise.
 |  
 |  isspace(...)
 |      B.isspace() -> bool
 |      
 |      Return True if all characters in B are whitespace
 |      and there is at least one character in B, False otherwise.
 |  
 |  istitle(...)
 |      B.istitle() -> bool
 |      
 |      Return True if B is a titlecased string and there is at least one
 |      character in B, i.e. uppercase characters may only follow uncased
 |      characters and lowercase characters only cased ones. Return False
 |      otherwise.
 |  
 |  isupper(...)
 |      B.isupper() -> bool
 |      
 |      Return True if all cased characters in B are uppercase and there is
 |      at least one cased character in B, False otherwise.
 |  
 |  join(self, iterable_of_bytes, /)
 |      Concatenate any number of bytes objects.
 |      
 |      The bytes whose method is called is inserted in between each pair.
 |      
 |      The result is returned as a new bytes object.
 |      
 |      Example: b'.'.join([b'ab', b'pq', b'rs']) -> b'ab.pq.rs'.
 |  
 |  ljust(...)
 |      B.ljust(width[, fillchar]) -> copy of B
 |      
 |      Return B left justified in a string of length width. Padding is
 |      done using the specified fill character (default is a space).
 |  
 |  lower(...)
 |      B.lower() -> copy of B
 |      
 |      Return a copy of B with all ASCII characters converted to lowercase.
 |  
 |  lstrip(self, bytes=None, /)
 |      Strip leading bytes contained in the argument.
 |      
 |      If the argument is omitted or None, strip leading  ASCII whitespace.
 |  
 |  partition(self, sep, /)
 |      Partition the bytes into three parts using the given separator.
 |      
 |      This will search for the separator sep in the bytes. If the separator is found,
 |      returns a 3-tuple containing the part before the separator, the separator
 |      itself, and the part after it.
 |      
 |      If the separator is not found, returns a 3-tuple containing the original bytes
 |      object and two empty bytes objects.
 |  
 |  replace(self, old, new, count=-1, /)
 |      Return a copy with all occurrences of substring old replaced by new.
 |      
 |        count
 |          Maximum number of occurrences to replace.
 |          -1 (the default value) means replace all occurrences.
 |      
 |      If the optional argument count is given, only the first count occurrences are
 |      replaced.
 |  
 |  rfind(...)
 |      B.rfind(sub[, start[, end]]) -> int
 |      
 |      Return the highest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Return -1 on failure.
 |  
 |  rindex(...)
 |      B.rindex(sub[, start[, end]]) -> int
 |      
 |      Return the highest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Raise ValueError when the subsection is not found.
 |  
 |  rjust(...)
 |      B.rjust(width[, fillchar]) -> copy of B
 |      
 |      Return B right justified in a string of length width. Padding is
 |      done using the specified fill character (default is a space)
 |  
 |  rpartition(self, sep, /)
 |      Partition the bytes into three parts using the given separator.
 |      
 |      This will search for the separator sep in the bytes, starting at the end. If
 |      the separator is found, returns a 3-tuple containing the part before the
 |      separator, the separator itself, and the part after it.
 |      
 |      If the separator is not found, returns a 3-tuple containing two empty bytes
 |      objects and the original bytes object.
 |  
 |  rsplit(self, /, sep=None, maxsplit=-1)
 |      Return a list of the sections in the bytes, using sep as the delimiter.
 |      
 |        sep
 |          The delimiter according which to split the bytes.
 |          None (the default value) means split on ASCII whitespace characters
 |          (space, tab, return, newline, formfeed, vertical tab).
 |        maxsplit
 |          Maximum number of splits to do.
 |          -1 (the default value) means no limit.
 |      
 |      Splitting is done starting at the end of the bytes and working to the front.
 |  
 |  rstrip(self, bytes=None, /)
 |      Strip trailing bytes contained in the argument.
 |      
 |      If the argument is omitted or None, strip trailing ASCII whitespace.
 |  
 |  split(self, /, sep=None, maxsplit=-1)
 |      Return a list of the sections in the bytes, using sep as the delimiter.
 |      
 |      sep
 |        The delimiter according which to split the bytes.
 |        None (the default value) means split on ASCII whitespace characters
 |        (space, tab, return, newline, formfeed, vertical tab).
 |      maxsplit
 |        Maximum number of splits to do.
 |        -1 (the default value) means no limit.
 |  
 |  splitlines(self, /, keepends=False)
 |      Return a list of the lines in the bytes, breaking at line boundaries.
 |      
 |      Line breaks are not included in the resulting list unless keepends is given and
 |      true.
 |  
 |  startswith(...)
 |      B.startswith(prefix[, start[, end]]) -> bool
 |      
 |      Return True if B starts with the specified prefix, False otherwise.
 |      With optional start, test B beginning at that position.
 |      With optional end, stop comparing B at that position.
 |      prefix can also be a tuple of bytes to try.
 |  
 |  strip(self, bytes=None, /)
 |      Strip leading and trailing bytes contained in the argument.
 |      
 |      If the argument is omitted or None, strip leading and trailing ASCII whitespace.
 |  
 |  swapcase(...)
 |      B.swapcase() -> copy of B
 |      
 |      Return a copy of B with uppercase ASCII characters converted
 |      to lowercase ASCII and vice versa.
 |  
 |  title(...)
 |      B.title() -> copy of B
 |      
 |      Return a titlecased version of B, i.e. ASCII words start with uppercase
 |      characters, all remaining cased characters have lowercase.
 |  
 |  translate(self, table, /, delete=b'')
 |      Return a copy with each character mapped by the given translation table.
 |      
 |        table
 |          Translation table, which must be a bytes object of length 256.
 |      
 |      All characters occurring in the optional argument delete are removed.
 |      The remaining characters are mapped through the given translation table.
 |  
 |  upper(...)
 |      B.upper() -> copy of B
 |      
 |      Return a copy of B with all ASCII characters converted to uppercase.
 |  
 |  zfill(...)
 |      B.zfill(width) -> copy of B
 |      
 |      Pad a numeric string B with zeros on the left, to fill a field
 |      of the specified width.  B is never truncated.
 |  
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |  
 |  maketrans(frm, to, /)
 |      Return a translation table useable for the bytes or bytearray translate method.
 |      
 |      The returned table will be one where each byte in frm is mapped to the byte at
 |      the same position in to.
 |      
 |      The bytes objects frm and to must be of the same length.
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.netcdf.dtype,io.netcdf,dtype,"Python Library Documentation: class dtype in module numpy

class dtype(builtins.object)
 |  dtype(obj, align=False, copy=False)
 |  
 |  Create a data type object.
 |  
 |  A numpy array is homogeneous, and contains elements described by a
 |  dtype object. A dtype object can be constructed from different
 |  combinations of fundamental numeric types.
 |  
 |  Parameters
 |  ----------
 |  obj
 |      Object to be converted to a data type object.
 |  align : bool, optional
 |      Add padding to the fields to match what a C compiler would output
 |      for a similar C-struct. Can be ``True`` only if `obj` is a dictionary
 |      or a comma-separated string. If a struct dtype is being created,
 |      this also sets a sticky alignment flag ``isalignedstruct``.
 |  copy : bool, optional
 |      Make a new copy of the data-type object. If ``False``, the result
 |      may just be a reference to a built-in data-type object.
 |  
 |  See also
 |  --------
 |  result_type
 |  
 |  Examples
 |  --------
 |  Using array-scalar type:
 |  
 |  >>> np.dtype(np.int16)
 |  dtype('int16')
 |  
 |  Structured type, one field name 'f1', containing int16:
 |  
 |  >>> np.dtype([('f1', np.int16)])
 |  dtype([('f1', '<i2')])
 |  
 |  Structured type, one field named 'f1', in itself containing a structured
 |  type with one field:
 |  
 |  >>> np.dtype([('f1', [('f1', np.int16)])])
 |  dtype([('f1', [('f1', '<i2')])])
 |  
 |  Structured type, two fields: the first field contains an unsigned int, the
 |  second an int32:
 |  
 |  >>> np.dtype([('f1', np.uint), ('f2', np.int32)])
 |  dtype([('f1', '<u4'), ('f2', '<i4')])
 |  
 |  Using array-protocol type strings:
 |  
 |  >>> np.dtype([('a','f8'),('b','S10')])
 |  dtype([('a', '<f8'), ('b', '|S10')])
 |  
 |  Using comma-separated field formats.  The shape is (2,3):
 |  
 |  >>> np.dtype(""i4, (2,3)f8"")
 |  dtype([('f0', '<i4'), ('f1', '<f8', (2, 3))])
 |  
 |  Using tuples.  ``int`` is a fixed type, 3 the field's shape.  ``void``
 |  is a flexible type, here of size 10:
 |  
 |  >>> np.dtype([('hello',(int,3)),('world',np.void,10)])
 |  dtype([('hello', '<i4', 3), ('world', '|V10')])
 |  
 |  Subdivide ``int16`` into 2 ``int8``'s, called x and y.  0 and 1 are
 |  the offsets in bytes:
 |  
 |  >>> np.dtype((np.int16, {'x':(np.int8,0), 'y':(np.int8,1)}))
 |  dtype(('<i2', [('x', '|i1'), ('y', '|i1')]))
 |  
 |  Using dictionaries.  Two fields named 'gender' and 'age':
 |  
 |  >>> np.dtype({'names':['gender','age'], 'formats':['S1',np.uint8]})
 |  dtype([('gender', '|S1'), ('age', '|u1')])
 |  
 |  Offsets in bytes, here 0 and 25:
 |  
 |  >>> np.dtype({'surname':('S25',0),'age':(np.uint8,25)})
 |  dtype([('surname', '|S25'), ('age', '|u1')])
 |  
 |  Methods defined here:
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.n
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rmul__(self, value, /)
 |      Return self*value.
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  newbyteorder(...)
 |      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_order : string, 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
 |          * {'<', 'L'} - little endian
 |          * {'>', 'B'} - big endian
 |          * {'=', 'N'} - native order
 |          * {'|', 'I'} - ignore (no change to byte order)
 |      
 |          The code does a case-insensitive check on the first letter of
 |          `new_order` for these alternatives.  For example, any of '>'
 |          or 'B' or 'b' or 'brian' are valid to specify big-endian.
 |      
 |      Returns
 |      -------
 |      new_dtype : dtype
 |          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
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  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.
 |  
 |  base
 |  
 |  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
 |  
 |  char
 |      A unique character code for each of the 21 different built-in types.
 |  
 |  descr
 |      PEP3118 interface description of the data-type.
 |      
 |      The format is that required by the 'descr' key in the
 |      PEP3118 `__array_interface__` attribute.
 |      
 |      Warning: This attribute exists specifically for PEP3118 compliance, and
 |      is not a datatype description compatible with `np.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])
 |      
 |      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)}
 |  
 |  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.
 |  
 |  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.
 |  
 |  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.
 |  
 |  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
 |         :ref:`user.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
 |  
 |  isnative
 |      Boolean indicating whether the byte order of this dtype is native
 |      to the platform.
 |  
 |  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.
 |  
 |  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
 |      =  ======================
 |  
 |  metadata
 |  
 |  name
 |      A bit-width name for this data-type.
 |      
 |      Un-sized flexible data-type objects do not have this attribute.
 |  
 |  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')
 |  
 |  ndim
 |      Number of dimensions of the sub-array if this data type describes a
 |      sub-array, and ``0`` otherwise.
 |      
 |      .. versionadded:: 1.13.0
 |  
 |  num
 |      A unique number for each of the 21 different built-in types.
 |      
 |      These are roughly ordered from least-to-most precision.
 |  
 |  shape
 |      Shape tuple of the sub-array if this data type describes a sub-array,
 |      and ``()`` otherwise.
 |  
 |  str
 |      The array-protocol typestring of this data-type object.
 |  
 |  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.
 |  
 |  type
 |      The type object used to instantiate a scalar of this data-type.
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.netcdf.dtype,io.netcdf,dtype,"Python Library Documentation: class dtype in module numpy

class dtype(builtins.object)
 |  dtype(obj, align=False, copy=False)
 |  
 |  Create a data type object.
 |  
 |  A numpy array is homogeneous, and contains elements described by a
 |  dtype object. A dtype object can be constructed from different
 |  combinations of fundamental numeric types.
 |  
 |  Parameters
 |  ----------
 |  obj
 |      Object to be converted to a data type object.
 |  align : bool, optional
 |      Add padding to the fields to match what a C compiler would output
 |      for a similar C-struct. Can be ``True`` only if `obj` is a dictionary
 |      or a comma-separated string. If a struct dtype is being created,
 |      this also sets a sticky alignment flag ``isalignedstruct``.
 |  copy : bool, optional
 |      Make a new copy of the data-type object. If ``False``, the result
 |      may just be a reference to a built-in data-type object.
 |  
 |  See also
 |  --------
 |  result_type
 |  
 |  Examples
 |  --------
 |  Using array-scalar type:
 |  
 |  >>> np.dtype(np.int16)
 |  dtype('int16')
 |  
 |  Structured type, one field name 'f1', containing int16:
 |  
 |  >>> np.dtype([('f1', np.int16)])
 |  dtype([('f1', '<i2')])
 |  
 |  Structured type, one field named 'f1', in itself containing a structured
 |  type with one field:
 |  
 |  >>> np.dtype([('f1', [('f1', np.int16)])])
 |  dtype([('f1', [('f1', '<i2')])])
 |  
 |  Structured type, two fields: the first field contains an unsigned int, the
 |  second an int32:
 |  
 |  >>> np.dtype([('f1', np.uint), ('f2', np.int32)])
 |  dtype([('f1', '<u4'), ('f2', '<i4')])
 |  
 |  Using array-protocol type strings:
 |  
 |  >>> np.dtype([('a','f8'),('b','S10')])
 |  dtype([('a', '<f8'), ('b', '|S10')])
 |  
 |  Using comma-separated field formats.  The shape is (2,3):
 |  
 |  >>> np.dtype(""i4, (2,3)f8"")
 |  dtype([('f0', '<i4'), ('f1', '<f8', (2, 3))])
 |  
 |  Using tuples.  ``int`` is a fixed type, 3 the field's shape.  ``void``
 |  is a flexible type, here of size 10:
 |  
 |  >>> np.dtype([('hello',(int,3)),('world',np.void,10)])
 |  dtype([('hello', '<i4', 3), ('world', '|V10')])
 |  
 |  Subdivide ``int16`` into 2 ``int8``'s, called x and y.  0 and 1 are
 |  the offsets in bytes:
 |  
 |  >>> np.dtype((np.int16, {'x':(np.int8,0), 'y':(np.int8,1)}))
 |  dtype(('<i2', [('x', '|i1'), ('y', '|i1')]))
 |  
 |  Using dictionaries.  Two fields named 'gender' and 'age':
 |  
 |  >>> np.dtype({'names':['gender','age'], 'formats':['S1',np.uint8]})
 |  dtype([('gender', '|S1'), ('age', '|u1')])
 |  
 |  Offsets in bytes, here 0 and 25:
 |  
 |  >>> np.dtype({'surname':('S25',0),'age':(np.uint8,25)})
 |  dtype([('surname', '|S25'), ('age', '|u1')])
 |  
 |  Methods defined here:
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.n
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rmul__(self, value, /)
 |      Return self*value.
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  newbyteorder(...)
 |      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_order : string, 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
 |          * {'<', 'L'} - little endian
 |          * {'>', 'B'} - big endian
 |          * {'=', 'N'} - native order
 |          * {'|', 'I'} - ignore (no change to byte order)
 |      
 |          The code does a case-insensitive check on the first letter of
 |          `new_order` for these alternatives.  For example, any of '>'
 |          or 'B' or 'b' or 'brian' are valid to specify big-endian.
 |      
 |      Returns
 |      -------
 |      new_dtype : dtype
 |          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
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  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.
 |  
 |  base
 |  
 |  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
 |  
 |  char
 |      A unique character code for each of the 21 different built-in types.
 |  
 |  descr
 |      PEP3118 interface description of the data-type.
 |      
 |      The format is that required by the 'descr' key in the
 |      PEP3118 `__array_interface__` attribute.
 |      
 |      Warning: This attribute exists specifically for PEP3118 compliance, and
 |      is not a datatype description compatible with `np.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])
 |      
 |      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)}
 |  
 |  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.
 |  
 |  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.
 |  
 |  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.
 |  
 |  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
 |         :ref:`user.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
 |  
 |  isnative
 |      Boolean indicating whether the byte order of this dtype is native
 |      to the platform.
 |  
 |  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.
 |  
 |  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
 |      =  ======================
 |  
 |  metadata
 |  
 |  name
 |      A bit-width name for this data-type.
 |      
 |      Un-sized flexible data-type objects do not have this attribute.
 |  
 |  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')
 |  
 |  ndim
 |      Number of dimensions of the sub-array if this data type describes a
 |      sub-array, and ``0`` otherwise.
 |      
 |      .. versionadded:: 1.13.0
 |  
 |  num
 |      A unique number for each of the 21 different built-in types.
 |      
 |      These are roughly ordered from least-to-most precision.
 |  
 |  shape
 |      Shape tuple of the sub-array if this data type describes a sub-array,
 |      and ``()`` otherwise.
 |  
 |  str
 |      The array-protocol typestring of this data-type object.
 |  
 |  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.
 |  
 |  type
 |      The type object used to instantiate a scalar of this data-type.
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.netcdf.netcdf_file,io.netcdf,netcdf_file,"Python Library Documentation: class netcdf_file in module scipy.io.netcdf

class netcdf_file(builtins.object)
 |  A file object for NetCDF data.
 |  
 |  A `netcdf_file` object has two standard attributes: `dimensions` and
 |  `variables`. The values of both are dictionaries, mapping dimension
 |  names to their associated lengths and variable names to variables,
 |  respectively. Application programs should never modify these
 |  dictionaries.
 |  
 |  All other attributes correspond to global attributes defined in the
 |  NetCDF file. Global file attributes are created by assigning to an
 |  attribute of the `netcdf_file` object.
 |  
 |  Parameters
 |  ----------
 |  filename : string or file-like
 |      string -> filename
 |  mode : {'r', 'w', 'a'}, optional
 |      read-write-append mode, default is 'r'
 |  mmap : None or bool, optional
 |      Whether to mmap `filename` when reading.  Default is True
 |      when `filename` is a file name, False when `filename` is a
 |      file-like object. Note that when mmap is in use, data arrays
 |      returned refer directly to the mmapped data on disk, and the
 |      file cannot be closed as long as references to it exist.
 |  version : {1, 2}, optional
 |      version of netcdf to read / write, where 1 means *Classic
 |      format* and 2 means *64-bit offset format*.  Default is 1.  See
 |      `here <https://www.unidata.ucar.edu/software/netcdf/docs/netcdf_introduction.html#select_format>`__
 |      for more info.
 |  maskandscale : bool, optional
 |      Whether to automatically scale and/or mask data based on attributes.
 |      Default is False.
 |  
 |  Notes
 |  -----
 |  The major advantage of this module over other modules is that it doesn't
 |  require the code to be linked to the NetCDF libraries. This module is
 |  derived from `pupynere <https://bitbucket.org/robertodealmeida/pupynere/>`_.
 |  
 |  NetCDF files are a self-describing binary data format. The file contains
 |  metadata that describes the dimensions and variables in the file. More
 |  details about NetCDF files can be found `here
 |  <https://www.unidata.ucar.edu/software/netcdf/docs/user_guide.html>`__. There
 |  are three main sections to a NetCDF data structure:
 |  
 |  1. Dimensions
 |  2. Variables
 |  3. Attributes
 |  
 |  The dimensions section records the name and length of each dimension used
 |  by the variables. The variables would then indicate which dimensions it
 |  uses and any attributes such as data units, along with containing the data
 |  values for the variable. It is good practice to include a
 |  variable that is the same name as a dimension to provide the values for
 |  that axes. Lastly, the attributes section would contain additional
 |  information such as the name of the file creator or the instrument used to
 |  collect the data.
 |  
 |  When writing data to a NetCDF file, there is often the need to indicate the
 |  'record dimension'. A record dimension is the unbounded dimension for a
 |  variable. For example, a temperature variable may have dimensions of
 |  latitude, longitude and time. If one wants to add more temperature data to
 |  the NetCDF file as time progresses, then the temperature variable should
 |  have the time dimension flagged as the record dimension.
 |  
 |  In addition, the NetCDF file header contains the position of the data in
 |  the file, so access can be done in an efficient manner without loading
 |  unnecessary data into memory. It uses the ``mmap`` module to create
 |  Numpy arrays mapped to the data on disk, for the same purpose.
 |  
 |  Note that when `netcdf_file` is used to open a file with mmap=True
 |  (default for read-only), arrays returned by it refer to data
 |  directly on the disk. The file should not be closed, and cannot be cleanly
 |  closed when asked, if such arrays are alive. You may want to copy data arrays
 |  obtained from mmapped Netcdf file if they are to be processed after the file
 |  is closed, see the example below.
 |  
 |  Examples
 |  --------
 |  To create a NetCDF file:
 |  
 |  >>> from scipy.io import netcdf
 |  >>> f = netcdf.netcdf_file('simple.nc', 'w')
 |  >>> f.history = 'Created for a test'
 |  >>> f.createDimension('time', 10)
 |  >>> time = f.createVariable('time', 'i', ('time',))
 |  >>> time[:] = np.arange(10)
 |  >>> time.units = 'days since 2008-01-01'
 |  >>> f.close()
 |  
 |  Note the assignment of ``arange(10)`` to ``time[:]``.  Exposing the slice
 |  of the time variable allows for the data to be set in the object, rather
 |  than letting ``arange(10)`` overwrite the ``time`` variable.
 |  
 |  To read the NetCDF file we just created:
 |  
 |  >>> from scipy.io import netcdf
 |  >>> f = netcdf.netcdf_file('simple.nc', 'r')
 |  >>> print(f.history)
 |  b'Created for a test'
 |  >>> time = f.variables['time']
 |  >>> print(time.units)
 |  b'days since 2008-01-01'
 |  >>> print(time.shape)
 |  (10,)
 |  >>> print(time[-1])
 |  9
 |  
 |  NetCDF files, when opened read-only, return arrays that refer
 |  directly to memory-mapped data on disk:
 |  
 |  >>> data = time[:]
 |  >>> data.base.base
 |  <mmap.mmap object at 0x7fe753763180>
 |  
 |  If the data is to be processed after the file is closed, it needs
 |  to be copied to main memory:
 |  
 |  >>> data = time[:].copy()
 |  >>> f.close()
 |  >>> data.mean()
 |  4.5
 |  
 |  A NetCDF file can also be used as context manager:
 |  
 |  >>> from scipy.io import netcdf
 |  >>> with netcdf.netcdf_file('simple.nc', 'r') as f:
 |  ...     print(f.history)
 |  b'Created for a test'
 |  
 |  Methods defined here:
 |  
 |  __del__ = close(self)
 |  
 |  __enter__(self)
 |  
 |  __exit__(self, type, value, traceback)
 |  
 |  __init__(self, filename, mode='r', mmap=None, version=1, maskandscale=False)
 |      Initialize netcdf_file from fileobj (str or file-like).
 |  
 |  __setattr__(self, attr, value)
 |      Implement setattr(self, name, value).
 |  
 |  close(self)
 |      Closes the NetCDF file.
 |  
 |  createDimension(self, name, length)
 |      Adds a dimension to the Dimension section of the NetCDF data structure.
 |      
 |      Note that this function merely adds a new dimension that the variables can
 |      reference.  The values for the dimension, if desired, should be added as
 |      a variable using `createVariable`, referring to this dimension.
 |      
 |      Parameters
 |      ----------
 |      name : str
 |          Name of the dimension (Eg, 'lat' or 'time').
 |      length : int
 |          Length of the dimension.
 |      
 |      See Also
 |      --------
 |      createVariable
 |  
 |  createVariable(self, name, type, dimensions)
 |      Create an empty variable for the `netcdf_file` object, specifying its data
 |      type and the dimensions it uses.
 |      
 |      Parameters
 |      ----------
 |      name : str
 |          Name of the new variable.
 |      type : dtype or str
 |          Data type of the variable.
 |      dimensions : sequence of str
 |          List of the dimension names used by the variable, in the desired order.
 |      
 |      Returns
 |      -------
 |      variable : netcdf_variable
 |          The newly created ``netcdf_variable`` object.
 |          This object has also been added to the `netcdf_file` object as well.
 |      
 |      See Also
 |      --------
 |      createDimension
 |      
 |      Notes
 |      -----
 |      Any dimensions to be used by the variable should already exist in the
 |      NetCDF data structure or should be created by `createDimension` prior to
 |      creating the NetCDF variable.
 |  
 |  flush(self)
 |      Perform a sync-to-disk flush if the `netcdf_file` object is in write mode.
 |      
 |      See Also
 |      --------
 |      sync : Identical function
 |  
 |  sync = flush(self)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"(""(self, filename, mode='r', mmap=None, version=1, maskandscale=False)"",)",scipy,1.1.0,scipy.io.netcdf.netcdf_file,io.netcdf,netcdf_file,"Python Library Documentation: class netcdf_file in module scipy.io.netcdf

class netcdf_file(builtins.object)
 |  A file object for NetCDF data.
 |  
 |  A `netcdf_file` object has two standard attributes: `dimensions` and
 |  `variables`. The values of both are dictionaries, mapping dimension
 |  names to their associated lengths and variable names to variables,
 |  respectively. Application programs should never modify these
 |  dictionaries.
 |  
 |  All other attributes correspond to global attributes defined in the
 |  NetCDF file. Global file attributes are created by assigning to an
 |  attribute of the `netcdf_file` object.
 |  
 |  Parameters
 |  ----------
 |  filename : string or file-like
 |      string -> filename
 |  mode : {'r', 'w', 'a'}, optional
 |      read-write-append mode, default is 'r'
 |  mmap : None or bool, optional
 |      Whether to mmap `filename` when reading.  Default is True
 |      when `filename` is a file name, False when `filename` is a
 |      file-like object. Note that when mmap is in use, data arrays
 |      returned refer directly to the mmapped data on disk, and the
 |      file cannot be closed as long as references to it exist.
 |  version : {1, 2}, optional
 |      version of netcdf to read / write, where 1 means *Classic
 |      format* and 2 means *64-bit offset format*.  Default is 1.  See
 |      `here <https://www.unidata.ucar.edu/software/netcdf/docs/netcdf_introduction.html#select_format>`__
 |      for more info.
 |  maskandscale : bool, optional
 |      Whether to automatically scale and/or mask data based on attributes.
 |      Default is False.
 |  
 |  Notes
 |  -----
 |  The major advantage of this module over other modules is that it doesn't
 |  require the code to be linked to the NetCDF libraries. This module is
 |  derived from `pupynere <https://bitbucket.org/robertodealmeida/pupynere/>`_.
 |  
 |  NetCDF files are a self-describing binary data format. The file contains
 |  metadata that describes the dimensions and variables in the file. More
 |  details about NetCDF files can be found `here
 |  <https://www.unidata.ucar.edu/software/netcdf/docs/user_guide.html>`__. There
 |  are three main sections to a NetCDF data structure:
 |  
 |  1. Dimensions
 |  2. Variables
 |  3. Attributes
 |  
 |  The dimensions section records the name and length of each dimension used
 |  by the variables. The variables would then indicate which dimensions it
 |  uses and any attributes such as data units, along with containing the data
 |  values for the variable. It is good practice to include a
 |  variable that is the same name as a dimension to provide the values for
 |  that axes. Lastly, the attributes section would contain additional
 |  information such as the name of the file creator or the instrument used to
 |  collect the data.
 |  
 |  When writing data to a NetCDF file, there is often the need to indicate the
 |  'record dimension'. A record dimension is the unbounded dimension for a
 |  variable. For example, a temperature variable may have dimensions of
 |  latitude, longitude and time. If one wants to add more temperature data to
 |  the NetCDF file as time progresses, then the temperature variable should
 |  have the time dimension flagged as the record dimension.
 |  
 |  In addition, the NetCDF file header contains the position of the data in
 |  the file, so access can be done in an efficient manner without loading
 |  unnecessary data into memory. It uses the ``mmap`` module to create
 |  Numpy arrays mapped to the data on disk, for the same purpose.
 |  
 |  Note that when `netcdf_file` is used to open a file with mmap=True
 |  (default for read-only), arrays returned by it refer to data
 |  directly on the disk. The file should not be closed, and cannot be cleanly
 |  closed when asked, if such arrays are alive. You may want to copy data arrays
 |  obtained from mmapped Netcdf file if they are to be processed after the file
 |  is closed, see the example below.
 |  
 |  Examples
 |  --------
 |  To create a NetCDF file:
 |  
 |  >>> from scipy.io import netcdf
 |  >>> f = netcdf.netcdf_file('simple.nc', 'w')
 |  >>> f.history = 'Created for a test'
 |  >>> f.createDimension('time', 10)
 |  >>> time = f.createVariable('time', 'i', ('time',))
 |  >>> time[:] = np.arange(10)
 |  >>> time.units = 'days since 2008-01-01'
 |  >>> f.close()
 |  
 |  Note the assignment of ``arange(10)`` to ``time[:]``.  Exposing the slice
 |  of the time variable allows for the data to be set in the object, rather
 |  than letting ``arange(10)`` overwrite the ``time`` variable.
 |  
 |  To read the NetCDF file we just created:
 |  
 |  >>> from scipy.io import netcdf
 |  >>> f = netcdf.netcdf_file('simple.nc', 'r')
 |  >>> print(f.history)
 |  b'Created for a test'
 |  >>> time = f.variables['time']
 |  >>> print(time.units)
 |  b'days since 2008-01-01'
 |  >>> print(time.shape)
 |  (10,)
 |  >>> print(time[-1])
 |  9
 |  
 |  NetCDF files, when opened read-only, return arrays that refer
 |  directly to memory-mapped data on disk:
 |  
 |  >>> data = time[:]
 |  >>> data.base.base
 |  <mmap.mmap object at 0x7fe753763180>
 |  
 |  If the data is to be processed after the file is closed, it needs
 |  to be copied to main memory:
 |  
 |  >>> data = time[:].copy()
 |  >>> f.close()
 |  >>> data.mean()
 |  4.5
 |  
 |  A NetCDF file can also be used as context manager:
 |  
 |  >>> from scipy.io import netcdf
 |  >>> with netcdf.netcdf_file('simple.nc', 'r') as f:
 |  ...     print(f.history)
 |  b'Created for a test'
 |  
 |  Methods defined here:
 |  
 |  __del__ = close(self)
 |  
 |  __enter__(self)
 |  
 |  __exit__(self, type, value, traceback)
 |  
 |  __init__(self, filename, mode='r', mmap=None, version=1, maskandscale=False)
 |      Initialize netcdf_file from fileobj (str or file-like).
 |  
 |  __setattr__(self, attr, value)
 |      Implement setattr(self, name, value).
 |  
 |  close(self)
 |      Closes the NetCDF file.
 |  
 |  createDimension(self, name, length)
 |      Adds a dimension to the Dimension section of the NetCDF data structure.
 |      
 |      Note that this function merely adds a new dimension that the variables can
 |      reference.  The values for the dimension, if desired, should be added as
 |      a variable using `createVariable`, referring to this dimension.
 |      
 |      Parameters
 |      ----------
 |      name : str
 |          Name of the dimension (Eg, 'lat' or 'time').
 |      length : int
 |          Length of the dimension.
 |      
 |      See Also
 |      --------
 |      createVariable
 |  
 |  createVariable(self, name, type, dimensions)
 |      Create an empty variable for the `netcdf_file` object, specifying its data
 |      type and the dimensions it uses.
 |      
 |      Parameters
 |      ----------
 |      name : str
 |          Name of the new variable.
 |      type : dtype or str
 |          Data type of the variable.
 |      dimensions : sequence of str
 |          List of the dimension names used by the variable, in the desired order.
 |      
 |      Returns
 |      -------
 |      variable : netcdf_variable
 |          The newly created ``netcdf_variable`` object.
 |          This object has also been added to the `netcdf_file` object as well.
 |      
 |      See Also
 |      --------
 |      createDimension
 |      
 |      Notes
 |      -----
 |      Any dimensions to be used by the variable should already exist in the
 |      NetCDF data structure or should be created by `createDimension` prior to
 |      creating the NetCDF variable.
 |  
 |  flush(self)
 |      Perform a sync-to-disk flush if the `netcdf_file` object is in write mode.
 |      
 |      See Also
 |      --------
 |      sync : Identical function
 |  
 |  sync = flush(self)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'filename', 'mode', 'mmap', 'version', 'maskandscale')","(nan, nan, 'r', None, 1, False)","(nan, nan, 'str', 'NoneType', 'int', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(self, filename, mode='r', mmap=None, version=1, maskandscale=False)"",)"
scipy,1.1.0,scipy.io.netcdf.netcdf_variable,io.netcdf,netcdf_variable,"Python Library Documentation: class netcdf_variable in module scipy.io.netcdf

class netcdf_variable(builtins.object)
 |  A data object for the `netcdf` module.
 |  
 |  `netcdf_variable` objects are constructed by calling the method
 |  `netcdf_file.createVariable` on the `netcdf_file` object. `netcdf_variable`
 |  objects behave much like array objects defined in numpy, except that their
 |  data resides in a file. Data is read by indexing and written by assigning
 |  to an indexed subset; the entire array can be accessed by the index ``[:]``
 |  or (for scalars) by using the methods `getValue` and `assignValue`.
 |  `netcdf_variable` objects also have attribute `shape` with the same meaning
 |  as for arrays, but the shape cannot be modified. There is another read-only
 |  attribute `dimensions`, whose value is the tuple of dimension names.
 |  
 |  All other attributes correspond to variable attributes defined in
 |  the NetCDF file. Variable attributes are created by assigning to an
 |  attribute of the `netcdf_variable` object.
 |  
 |  Parameters
 |  ----------
 |  data : array_like
 |      The data array that holds the values for the variable.
 |      Typically, this is initialized as empty, but with the proper shape.
 |  typecode : dtype character code
 |      Desired data-type for the data array.
 |  size : int
 |      Desired element size for the data array.
 |  shape : sequence of ints
 |      The shape of the array.  This should match the lengths of the
 |      variable's dimensions.
 |  dimensions : sequence of strings
 |      The names of the dimensions used by the variable.  Must be in the
 |      same order of the dimension lengths given by `shape`.
 |  attributes : dict, optional
 |      Attribute values (any type) keyed by string names.  These attributes
 |      become attributes for the netcdf_variable object.
 |  maskandscale : bool, optional
 |      Whether to automatically scale and/or mask data based on attributes.
 |      Default is False.
 |  
 |  
 |  Attributes
 |  ----------
 |  dimensions : list of str
 |      List of names of dimensions used by the variable object.
 |  isrec, shape
 |      Properties
 |  
 |  See also
 |  --------
 |  isrec, shape
 |  
 |  Methods defined here:
 |  
 |  __getitem__(self, index)
 |  
 |  __init__(self, data, typecode, size, shape, dimensions, attributes=None, maskandscale=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __setattr__(self, attr, value)
 |      Implement setattr(self, name, value).
 |  
 |  __setitem__(self, index, data)
 |  
 |  assignValue(self, value)
 |      Assign a scalar value to a `netcdf_variable` of length one.
 |      
 |      Parameters
 |      ----------
 |      value : scalar
 |          Scalar value (of compatible type) to assign to a length-one netcdf
 |          variable. This value will be written to file.
 |      
 |      Raises
 |      ------
 |      ValueError
 |          If the input is not a scalar, or if the destination is not a length-one
 |          netcdf variable.
 |  
 |  getValue(self)
 |      Retrieve a scalar value from a `netcdf_variable` of length one.
 |      
 |      Raises
 |      ------
 |      ValueError
 |          If the netcdf variable is an array of length greater than one,
 |          this exception will be raised.
 |  
 |  itemsize(self)
 |      Return the itemsize of the variable.
 |      
 |      Returns
 |      -------
 |      itemsize : int
 |          The element size of the variable (eg, 8 for float64).
 |  
 |  typecode(self)
 |      Return the typecode of the variable.
 |      
 |      Returns
 |      -------
 |      typecode : char
 |          The character typecode of the variable (eg, 'i' for int).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  isrec
 |      Returns whether the variable has a record dimension or not.
 |      
 |      A record dimension is a dimension along which additional data could be
 |      easily appended in the netcdf data structure without much rewriting of
 |      the data file. This attribute is a read-only property of the
 |      `netcdf_variable`.
 |  
 |  shape
 |      Returns the shape tuple of the data variable.
 |      
 |      This is a read-only attribute and can not be modified in the
 |      same manner of other numpy arrays.
",class,"('(self, data, typecode, size, shape, dimensions, attributes=None, maskandscale=False)',)",scipy,1.1.0,scipy.io.netcdf.netcdf_variable,io.netcdf,netcdf_variable,"Python Library Documentation: class netcdf_variable in module scipy.io.netcdf

class netcdf_variable(builtins.object)
 |  A data object for the `netcdf` module.
 |  
 |  `netcdf_variable` objects are constructed by calling the method
 |  `netcdf_file.createVariable` on the `netcdf_file` object. `netcdf_variable`
 |  objects behave much like array objects defined in numpy, except that their
 |  data resides in a file. Data is read by indexing and written by assigning
 |  to an indexed subset; the entire array can be accessed by the index ``[:]``
 |  or (for scalars) by using the methods `getValue` and `assignValue`.
 |  `netcdf_variable` objects also have attribute `shape` with the same meaning
 |  as for arrays, but the shape cannot be modified. There is another read-only
 |  attribute `dimensions`, whose value is the tuple of dimension names.
 |  
 |  All other attributes correspond to variable attributes defined in
 |  the NetCDF file. Variable attributes are created by assigning to an
 |  attribute of the `netcdf_variable` object.
 |  
 |  Parameters
 |  ----------
 |  data : array_like
 |      The data array that holds the values for the variable.
 |      Typically, this is initialized as empty, but with the proper shape.
 |  typecode : dtype character code
 |      Desired data-type for the data array.
 |  size : int
 |      Desired element size for the data array.
 |  shape : sequence of ints
 |      The shape of the array.  This should match the lengths of the
 |      variable's dimensions.
 |  dimensions : sequence of strings
 |      The names of the dimensions used by the variable.  Must be in the
 |      same order of the dimension lengths given by `shape`.
 |  attributes : dict, optional
 |      Attribute values (any type) keyed by string names.  These attributes
 |      become attributes for the netcdf_variable object.
 |  maskandscale : bool, optional
 |      Whether to automatically scale and/or mask data based on attributes.
 |      Default is False.
 |  
 |  
 |  Attributes
 |  ----------
 |  dimensions : list of str
 |      List of names of dimensions used by the variable object.
 |  isrec, shape
 |      Properties
 |  
 |  See also
 |  --------
 |  isrec, shape
 |  
 |  Methods defined here:
 |  
 |  __getitem__(self, index)
 |  
 |  __init__(self, data, typecode, size, shape, dimensions, attributes=None, maskandscale=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __setattr__(self, attr, value)
 |      Implement setattr(self, name, value).
 |  
 |  __setitem__(self, index, data)
 |  
 |  assignValue(self, value)
 |      Assign a scalar value to a `netcdf_variable` of length one.
 |      
 |      Parameters
 |      ----------
 |      value : scalar
 |          Scalar value (of compatible type) to assign to a length-one netcdf
 |          variable. This value will be written to file.
 |      
 |      Raises
 |      ------
 |      ValueError
 |          If the input is not a scalar, or if the destination is not a length-one
 |          netcdf variable.
 |  
 |  getValue(self)
 |      Retrieve a scalar value from a `netcdf_variable` of length one.
 |      
 |      Raises
 |      ------
 |      ValueError
 |          If the netcdf variable is an array of length greater than one,
 |          this exception will be raised.
 |  
 |  itemsize(self)
 |      Return the itemsize of the variable.
 |      
 |      Returns
 |      -------
 |      itemsize : int
 |          The element size of the variable (eg, 8 for float64).
 |  
 |  typecode(self)
 |      Return the typecode of the variable.
 |      
 |      Returns
 |      -------
 |      typecode : char
 |          The character typecode of the variable (eg, 'i' for int).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  isrec
 |      Returns whether the variable has a record dimension or not.
 |      
 |      A record dimension is a dimension along which additional data could be
 |      easily appended in the netcdf data structure without much rewriting of
 |      the data file. This attribute is a read-only property of the
 |      `netcdf_variable`.
 |  
 |  shape
 |      Returns the shape tuple of the data variable.
 |      
 |      This is a read-only attribute and can not be modified in the
 |      same manner of other numpy arrays.
",class,"('self', 'data', 'typecode', 'size', 'shape', 'dimensions', 'attributes', 'maskandscale')","(nan, nan, nan, nan, nan, nan, None, False)","(nan, nan, nan, nan, nan, nan, 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, data, typecode, size, shape, dimensions, attributes=None, maskandscale=False)',)"
scipy,1.1.0,scipy.io.netcdf.text_type,io.netcdf,str,"Python Library Documentation: class str in module builtins

class str(object)
 |  str(object='') -> str
 |  str(bytes_or_buffer[, encoding[, errors]]) -> str
 |  
 |  Create a new string object from the given object. If encoding or
 |  errors is specified, then the object must expose a data buffer
 |  that will be decoded using the given encoding and error handler.
 |  Otherwise, returns the result of object.__str__() (if defined)
 |  or repr(object).
 |  encoding defaults to sys.getdefaultencoding().
 |  errors defaults to 'strict'.
 |  
 |  Methods defined here:
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __format__(...)
 |      S.__format__(format_spec) -> str
 |      
 |      Return a formatted version of S as described by format_spec.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __getnewargs__(...)
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.n
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return self*value.
 |  
 |  __sizeof__(...)
 |      S.__sizeof__() -> size of S in memory, in bytes
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  capitalize(...)
 |      S.capitalize() -> str
 |      
 |      Return a capitalized version of S, i.e. make the first character
 |      have upper case and the rest lower case.
 |  
 |  casefold(...)
 |      S.casefold() -> str
 |      
 |      Return a version of S suitable for caseless comparisons.
 |  
 |  center(...)
 |      S.center(width[, fillchar]) -> str
 |      
 |      Return S centered in a string of length width. Padding is
 |      done using the specified fill character (default is a space)
 |  
 |  count(...)
 |      S.count(sub[, start[, end]]) -> int
 |      
 |      Return the number of non-overlapping occurrences of substring sub in
 |      string S[start:end].  Optional arguments start and end are
 |      interpreted as in slice notation.
 |  
 |  encode(...)
 |      S.encode(encoding='utf-8', errors='strict') -> bytes
 |      
 |      Encode S using the codec registered for encoding. Default encoding
 |      is 'utf-8'. errors may be given to set a different error
 |      handling scheme. Default is 'strict' meaning that encoding errors raise
 |      a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
 |      'xmlcharrefreplace' as well as any other name registered with
 |      codecs.register_error that can handle UnicodeEncodeErrors.
 |  
 |  endswith(...)
 |      S.endswith(suffix[, start[, end]]) -> bool
 |      
 |      Return True if S ends with the specified suffix, False otherwise.
 |      With optional start, test S beginning at that position.
 |      With optional end, stop comparing S at that position.
 |      suffix can also be a tuple of strings to try.
 |  
 |  expandtabs(...)
 |      S.expandtabs(tabsize=8) -> str
 |      
 |      Return a copy of S where all tab characters are expanded using spaces.
 |      If tabsize is not given, a tab size of 8 characters is assumed.
 |  
 |  find(...)
 |      S.find(sub[, start[, end]]) -> int
 |      
 |      Return the lowest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Return -1 on failure.
 |  
 |  format(...)
 |      S.format(*args, **kwargs) -> str
 |      
 |      Return a formatted version of S, using substitutions from args and kwargs.
 |      The substitutions are identified by braces ('{' and '}').
 |  
 |  format_map(...)
 |      S.format_map(mapping) -> str
 |      
 |      Return a formatted version of S, using substitutions from mapping.
 |      The substitutions are identified by braces ('{' and '}').
 |  
 |  index(...)
 |      S.index(sub[, start[, end]]) -> int
 |      
 |      Return the lowest index in S where substring sub is found, 
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Raises ValueError when the substring is not found.
 |  
 |  isalnum(...)
 |      S.isalnum() -> bool
 |      
 |      Return True if all characters in S are alphanumeric
 |      and there is at least one character in S, False otherwise.
 |  
 |  isalpha(...)
 |      S.isalpha() -> bool
 |      
 |      Return True if all characters in S are alphabetic
 |      and there is at least one character in S, False otherwise.
 |  
 |  isdecimal(...)
 |      S.isdecimal() -> bool
 |      
 |      Return True if there are only decimal characters in S,
 |      False otherwise.
 |  
 |  isdigit(...)
 |      S.isdigit() -> bool
 |      
 |      Return True if all characters in S are digits
 |      and there is at least one character in S, False otherwise.
 |  
 |  isidentifier(...)
 |      S.isidentifier() -> bool
 |      
 |      Return True if S is a valid identifier according
 |      to the language definition.
 |      
 |      Use keyword.iskeyword() to test for reserved identifiers
 |      such as ""def"" and ""class"".
 |  
 |  islower(...)
 |      S.islower() -> bool
 |      
 |      Return True if all cased characters in S are lowercase and there is
 |      at least one cased character in S, False otherwise.
 |  
 |  isnumeric(...)
 |      S.isnumeric() -> bool
 |      
 |      Return True if there are only numeric characters in S,
 |      False otherwise.
 |  
 |  isprintable(...)
 |      S.isprintable() -> bool
 |      
 |      Return True if all characters in S are considered
 |      printable in repr() or S is empty, False otherwise.
 |  
 |  isspace(...)
 |      S.isspace() -> bool
 |      
 |      Return True if all characters in S are whitespace
 |      and there is at least one character in S, False otherwise.
 |  
 |  istitle(...)
 |      S.istitle() -> bool
 |      
 |      Return True if S is a titlecased string and there is at least one
 |      character in S, i.e. upper- and titlecase characters may only
 |      follow uncased characters and lowercase characters only cased ones.
 |      Return False otherwise.
 |  
 |  isupper(...)
 |      S.isupper() -> bool
 |      
 |      Return True if all cased characters in S are uppercase and there is
 |      at least one cased character in S, False otherwise.
 |  
 |  join(...)
 |      S.join(iterable) -> str
 |      
 |      Return a string which is the concatenation of the strings in the
 |      iterable.  The separator between elements is S.
 |  
 |  ljust(...)
 |      S.ljust(width[, fillchar]) -> str
 |      
 |      Return S left-justified in a Unicode string of length width. Padding is
 |      done using the specified fill character (default is a space).
 |  
 |  lower(...)
 |      S.lower() -> str
 |      
 |      Return a copy of the string S converted to lowercase.
 |  
 |  lstrip(...)
 |      S.lstrip([chars]) -> str
 |      
 |      Return a copy of the string S with leading whitespace removed.
 |      If chars is given and not None, remove characters in chars instead.
 |  
 |  partition(...)
 |      S.partition(sep) -> (head, sep, tail)
 |      
 |      Search for the separator sep in S, and return the part before it,
 |      the separator itself, and the part after it.  If the separator is not
 |      found, return S and two empty strings.
 |  
 |  replace(...)
 |      S.replace(old, new[, count]) -> str
 |      
 |      Return a copy of S with all occurrences of substring
 |      old replaced by new.  If the optional argument count is
 |      given, only the first count occurrences are replaced.
 |  
 |  rfind(...)
 |      S.rfind(sub[, start[, end]]) -> int
 |      
 |      Return the highest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Return -1 on failure.
 |  
 |  rindex(...)
 |      S.rindex(sub[, start[, end]]) -> int
 |      
 |      Return the highest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Raises ValueError when the substring is not found.
 |  
 |  rjust(...)
 |      S.rjust(width[, fillchar]) -> str
 |      
 |      Return S right-justified in a string of length width. Padding is
 |      done using the specified fill character (default is a space).
 |  
 |  rpartition(...)
 |      S.rpartition(sep) -> (head, sep, tail)
 |      
 |      Search for the separator sep in S, starting at the end of S, and return
 |      the part before it, the separator itself, and the part after it.  If the
 |      separator is not found, return two empty strings and S.
 |  
 |  rsplit(...)
 |      S.rsplit(sep=None, maxsplit=-1) -> list of strings
 |      
 |      Return a list of the words in S, using sep as the
 |      delimiter string, starting at the end of the string and
 |      working to the front.  If maxsplit is given, at most maxsplit
 |      splits are done. If sep is not specified, any whitespace string
 |      is a separator.
 |  
 |  rstrip(...)
 |      S.rstrip([chars]) -> str
 |      
 |      Return a copy of the string S with trailing whitespace removed.
 |      If chars is given and not None, remove characters in chars instead.
 |  
 |  split(...)
 |      S.split(sep=None, maxsplit=-1) -> list of strings
 |      
 |      Return a list of the words in S, using sep as the
 |      delimiter string.  If maxsplit is given, at most maxsplit
 |      splits are done. If sep is not specified or is None, any
 |      whitespace string is a separator and empty strings are
 |      removed from the result.
 |  
 |  splitlines(...)
 |      S.splitlines([keepends]) -> list of strings
 |      
 |      Return a list of the lines in S, breaking at line boundaries.
 |      Line breaks are not included in the resulting list unless keepends
 |      is given and true.
 |  
 |  startswith(...)
 |      S.startswith(prefix[, start[, end]]) -> bool
 |      
 |      Return True if S starts with the specified prefix, False otherwise.
 |      With optional start, test S beginning at that position.
 |      With optional end, stop comparing S at that position.
 |      prefix can also be a tuple of strings to try.
 |  
 |  strip(...)
 |      S.strip([chars]) -> str
 |      
 |      Return a copy of the string S with leading and trailing
 |      whitespace removed.
 |      If chars is given and not None, remove characters in chars instead.
 |  
 |  swapcase(...)
 |      S.swapcase() -> str
 |      
 |      Return a copy of S with uppercase characters converted to lowercase
 |      and vice versa.
 |  
 |  title(...)
 |      S.title() -> str
 |      
 |      Return a titlecased version of S, i.e. words start with title case
 |      characters, all remaining cased characters have lower case.
 |  
 |  translate(...)
 |      S.translate(table) -> str
 |      
 |      Return a copy of the string S in which each character has been mapped
 |      through the given translation table. The table must implement
 |      lookup/indexing via __getitem__, for instance a dictionary or list,
 |      mapping Unicode ordinals to Unicode ordinals, strings, or None. If
 |      this operation raises LookupError, the character is left untouched.
 |      Characters mapped to None are deleted.
 |  
 |  upper(...)
 |      S.upper() -> str
 |      
 |      Return a copy of S converted to uppercase.
 |  
 |  zfill(...)
 |      S.zfill(width) -> str
 |      
 |      Pad a numeric string S with zeros on the left, to fill a field
 |      of the specified width. The string S is never truncated.
 |  
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |  
 |  maketrans(x, y=None, z=None, /)
 |      Return a translation table usable for str.translate().
 |      
 |      If there is only one argument, it must be a dictionary mapping Unicode
 |      ordinals (integers) or characters to Unicode ordinals, strings or None.
 |      Character keys will be then converted to ordinals.
 |      If there are two arguments, they must be strings of equal length, and
 |      in the resulting dictionary, each character in x will be mapped to the
 |      character at the same position in y. If there is a third argument, it
 |      must be a string, whose characters will be mapped to None in the result.
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.io.netcdf.text_type,io.netcdf,str,"Python Library Documentation: class str in module builtins

class str(object)
 |  str(object='') -> str
 |  str(bytes_or_buffer[, encoding[, errors]]) -> str
 |  
 |  Create a new string object from the given object. If encoding or
 |  errors is specified, then the object must expose a data buffer
 |  that will be decoded using the given encoding and error handler.
 |  Otherwise, returns the result of object.__str__() (if defined)
 |  or repr(object).
 |  encoding defaults to sys.getdefaultencoding().
 |  errors defaults to 'strict'.
 |  
 |  Methods defined here:
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __format__(...)
 |      S.__format__(format_spec) -> str
 |      
 |      Return a formatted version of S as described by format_spec.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __getnewargs__(...)
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.n
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return self*value.
 |  
 |  __sizeof__(...)
 |      S.__sizeof__() -> size of S in memory, in bytes
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  capitalize(...)
 |      S.capitalize() -> str
 |      
 |      Return a capitalized version of S, i.e. make the first character
 |      have upper case and the rest lower case.
 |  
 |  casefold(...)
 |      S.casefold() -> str
 |      
 |      Return a version of S suitable for caseless comparisons.
 |  
 |  center(...)
 |      S.center(width[, fillchar]) -> str
 |      
 |      Return S centered in a string of length width. Padding is
 |      done using the specified fill character (default is a space)
 |  
 |  count(...)
 |      S.count(sub[, start[, end]]) -> int
 |      
 |      Return the number of non-overlapping occurrences of substring sub in
 |      string S[start:end].  Optional arguments start and end are
 |      interpreted as in slice notation.
 |  
 |  encode(...)
 |      S.encode(encoding='utf-8', errors='strict') -> bytes
 |      
 |      Encode S using the codec registered for encoding. Default encoding
 |      is 'utf-8'. errors may be given to set a different error
 |      handling scheme. Default is 'strict' meaning that encoding errors raise
 |      a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
 |      'xmlcharrefreplace' as well as any other name registered with
 |      codecs.register_error that can handle UnicodeEncodeErrors.
 |  
 |  endswith(...)
 |      S.endswith(suffix[, start[, end]]) -> bool
 |      
 |      Return True if S ends with the specified suffix, False otherwise.
 |      With optional start, test S beginning at that position.
 |      With optional end, stop comparing S at that position.
 |      suffix can also be a tuple of strings to try.
 |  
 |  expandtabs(...)
 |      S.expandtabs(tabsize=8) -> str
 |      
 |      Return a copy of S where all tab characters are expanded using spaces.
 |      If tabsize is not given, a tab size of 8 characters is assumed.
 |  
 |  find(...)
 |      S.find(sub[, start[, end]]) -> int
 |      
 |      Return the lowest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Return -1 on failure.
 |  
 |  format(...)
 |      S.format(*args, **kwargs) -> str
 |      
 |      Return a formatted version of S, using substitutions from args and kwargs.
 |      The substitutions are identified by braces ('{' and '}').
 |  
 |  format_map(...)
 |      S.format_map(mapping) -> str
 |      
 |      Return a formatted version of S, using substitutions from mapping.
 |      The substitutions are identified by braces ('{' and '}').
 |  
 |  index(...)
 |      S.index(sub[, start[, end]]) -> int
 |      
 |      Return the lowest index in S where substring sub is found, 
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Raises ValueError when the substring is not found.
 |  
 |  isalnum(...)
 |      S.isalnum() -> bool
 |      
 |      Return True if all characters in S are alphanumeric
 |      and there is at least one character in S, False otherwise.
 |  
 |  isalpha(...)
 |      S.isalpha() -> bool
 |      
 |      Return True if all characters in S are alphabetic
 |      and there is at least one character in S, False otherwise.
 |  
 |  isdecimal(...)
 |      S.isdecimal() -> bool
 |      
 |      Return True if there are only decimal characters in S,
 |      False otherwise.
 |  
 |  isdigit(...)
 |      S.isdigit() -> bool
 |      
 |      Return True if all characters in S are digits
 |      and there is at least one character in S, False otherwise.
 |  
 |  isidentifier(...)
 |      S.isidentifier() -> bool
 |      
 |      Return True if S is a valid identifier according
 |      to the language definition.
 |      
 |      Use keyword.iskeyword() to test for reserved identifiers
 |      such as ""def"" and ""class"".
 |  
 |  islower(...)
 |      S.islower() -> bool
 |      
 |      Return True if all cased characters in S are lowercase and there is
 |      at least one cased character in S, False otherwise.
 |  
 |  isnumeric(...)
 |      S.isnumeric() -> bool
 |      
 |      Return True if there are only numeric characters in S,
 |      False otherwise.
 |  
 |  isprintable(...)
 |      S.isprintable() -> bool
 |      
 |      Return True if all characters in S are considered
 |      printable in repr() or S is empty, False otherwise.
 |  
 |  isspace(...)
 |      S.isspace() -> bool
 |      
 |      Return True if all characters in S are whitespace
 |      and there is at least one character in S, False otherwise.
 |  
 |  istitle(...)
 |      S.istitle() -> bool
 |      
 |      Return True if S is a titlecased string and there is at least one
 |      character in S, i.e. upper- and titlecase characters may only
 |      follow uncased characters and lowercase characters only cased ones.
 |      Return False otherwise.
 |  
 |  isupper(...)
 |      S.isupper() -> bool
 |      
 |      Return True if all cased characters in S are uppercase and there is
 |      at least one cased character in S, False otherwise.
 |  
 |  join(...)
 |      S.join(iterable) -> str
 |      
 |      Return a string which is the concatenation of the strings in the
 |      iterable.  The separator between elements is S.
 |  
 |  ljust(...)
 |      S.ljust(width[, fillchar]) -> str
 |      
 |      Return S left-justified in a Unicode string of length width. Padding is
 |      done using the specified fill character (default is a space).
 |  
 |  lower(...)
 |      S.lower() -> str
 |      
 |      Return a copy of the string S converted to lowercase.
 |  
 |  lstrip(...)
 |      S.lstrip([chars]) -> str
 |      
 |      Return a copy of the string S with leading whitespace removed.
 |      If chars is given and not None, remove characters in chars instead.
 |  
 |  partition(...)
 |      S.partition(sep) -> (head, sep, tail)
 |      
 |      Search for the separator sep in S, and return the part before it,
 |      the separator itself, and the part after it.  If the separator is not
 |      found, return S and two empty strings.
 |  
 |  replace(...)
 |      S.replace(old, new[, count]) -> str
 |      
 |      Return a copy of S with all occurrences of substring
 |      old replaced by new.  If the optional argument count is
 |      given, only the first count occurrences are replaced.
 |  
 |  rfind(...)
 |      S.rfind(sub[, start[, end]]) -> int
 |      
 |      Return the highest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Return -1 on failure.
 |  
 |  rindex(...)
 |      S.rindex(sub[, start[, end]]) -> int
 |      
 |      Return the highest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Raises ValueError when the substring is not found.
 |  
 |  rjust(...)
 |      S.rjust(width[, fillchar]) -> str
 |      
 |      Return S right-justified in a string of length width. Padding is
 |      done using the specified fill character (default is a space).
 |  
 |  rpartition(...)
 |      S.rpartition(sep) -> (head, sep, tail)
 |      
 |      Search for the separator sep in S, starting at the end of S, and return
 |      the part before it, the separator itself, and the part after it.  If the
 |      separator is not found, return two empty strings and S.
 |  
 |  rsplit(...)
 |      S.rsplit(sep=None, maxsplit=-1) -> list of strings
 |      
 |      Return a list of the words in S, using sep as the
 |      delimiter string, starting at the end of the string and
 |      working to the front.  If maxsplit is given, at most maxsplit
 |      splits are done. If sep is not specified, any whitespace string
 |      is a separator.
 |  
 |  rstrip(...)
 |      S.rstrip([chars]) -> str
 |      
 |      Return a copy of the string S with trailing whitespace removed.
 |      If chars is given and not None, remove characters in chars instead.
 |  
 |  split(...)
 |      S.split(sep=None, maxsplit=-1) -> list of strings
 |      
 |      Return a list of the words in S, using sep as the
 |      delimiter string.  If maxsplit is given, at most maxsplit
 |      splits are done. If sep is not specified or is None, any
 |      whitespace string is a separator and empty strings are
 |      removed from the result.
 |  
 |  splitlines(...)
 |      S.splitlines([keepends]) -> list of strings
 |      
 |      Return a list of the lines in S, breaking at line boundaries.
 |      Line breaks are not included in the resulting list unless keepends
 |      is given and true.
 |  
 |  startswith(...)
 |      S.startswith(prefix[, start[, end]]) -> bool
 |      
 |      Return True if S starts with the specified prefix, False otherwise.
 |      With optional start, test S beginning at that position.
 |      With optional end, stop comparing S at that position.
 |      prefix can also be a tuple of strings to try.
 |  
 |  strip(...)
 |      S.strip([chars]) -> str
 |      
 |      Return a copy of the string S with leading and trailing
 |      whitespace removed.
 |      If chars is given and not None, remove characters in chars instead.
 |  
 |  swapcase(...)
 |      S.swapcase() -> str
 |      
 |      Return a copy of S with uppercase characters converted to lowercase
 |      and vice versa.
 |  
 |  title(...)
 |      S.title() -> str
 |      
 |      Return a titlecased version of S, i.e. words start with title case
 |      characters, all remaining cased characters have lower case.
 |  
 |  translate(...)
 |      S.translate(table) -> str
 |      
 |      Return a copy of the string S in which each character has been mapped
 |      through the given translation table. The table must implement
 |      lookup/indexing via __getitem__, for instance a dictionary or list,
 |      mapping Unicode ordinals to Unicode ordinals, strings, or None. If
 |      this operation raises LookupError, the character is left untouched.
 |      Characters mapped to None are deleted.
 |  
 |  upper(...)
 |      S.upper() -> str
 |      
 |      Return a copy of S converted to uppercase.
 |  
 |  zfill(...)
 |      S.zfill(width) -> str
 |      
 |      Pad a numeric string S with zeros on the left, to fill a field
 |      of the specified width. The string S is never truncated.
 |  
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |  
 |  maketrans(x, y=None, z=None, /)
 |      Return a translation table usable for str.translate().
 |      
 |      If there is only one argument, it must be a dictionary mapping Unicode
 |      ordinals (integers) or characters to Unicode ordinals, strings or None.
 |      Character keys will be then converted to ordinals.
 |      If there are two arguments, they must be strings of equal length, and
 |      in the resulting dictionary, each character in x will be mapped to the
 |      character at the same position in y. If there is a third argument, it
 |      must be a string, whose characters will be mapped to None in the result.
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.io.netcdf_file,io,netcdf_file,"Python Library Documentation: class netcdf_file in module scipy.io.netcdf

class netcdf_file(builtins.object)
 |  A file object for NetCDF data.
 |  
 |  A `netcdf_file` object has two standard attributes: `dimensions` and
 |  `variables`. The values of both are dictionaries, mapping dimension
 |  names to their associated lengths and variable names to variables,
 |  respectively. Application programs should never modify these
 |  dictionaries.
 |  
 |  All other attributes correspond to global attributes defined in the
 |  NetCDF file. Global file attributes are created by assigning to an
 |  attribute of the `netcdf_file` object.
 |  
 |  Parameters
 |  ----------
 |  filename : string or file-like
 |      string -> filename
 |  mode : {'r', 'w', 'a'}, optional
 |      read-write-append mode, default is 'r'
 |  mmap : None or bool, optional
 |      Whether to mmap `filename` when reading.  Default is True
 |      when `filename` is a file name, False when `filename` is a
 |      file-like object. Note that when mmap is in use, data arrays
 |      returned refer directly to the mmapped data on disk, and the
 |      file cannot be closed as long as references to it exist.
 |  version : {1, 2}, optional
 |      version of netcdf to read / write, where 1 means *Classic
 |      format* and 2 means *64-bit offset format*.  Default is 1.  See
 |      `here <https://www.unidata.ucar.edu/software/netcdf/docs/netcdf_introduction.html#select_format>`__
 |      for more info.
 |  maskandscale : bool, optional
 |      Whether to automatically scale and/or mask data based on attributes.
 |      Default is False.
 |  
 |  Notes
 |  -----
 |  The major advantage of this module over other modules is that it doesn't
 |  require the code to be linked to the NetCDF libraries. This module is
 |  derived from `pupynere <https://bitbucket.org/robertodealmeida/pupynere/>`_.
 |  
 |  NetCDF files are a self-describing binary data format. The file contains
 |  metadata that describes the dimensions and variables in the file. More
 |  details about NetCDF files can be found `here
 |  <https://www.unidata.ucar.edu/software/netcdf/docs/user_guide.html>`__. There
 |  are three main sections to a NetCDF data structure:
 |  
 |  1. Dimensions
 |  2. Variables
 |  3. Attributes
 |  
 |  The dimensions section records the name and length of each dimension used
 |  by the variables. The variables would then indicate which dimensions it
 |  uses and any attributes such as data units, along with containing the data
 |  values for the variable. It is good practice to include a
 |  variable that is the same name as a dimension to provide the values for
 |  that axes. Lastly, the attributes section would contain additional
 |  information such as the name of the file creator or the instrument used to
 |  collect the data.
 |  
 |  When writing data to a NetCDF file, there is often the need to indicate the
 |  'record dimension'. A record dimension is the unbounded dimension for a
 |  variable. For example, a temperature variable may have dimensions of
 |  latitude, longitude and time. If one wants to add more temperature data to
 |  the NetCDF file as time progresses, then the temperature variable should
 |  have the time dimension flagged as the record dimension.
 |  
 |  In addition, the NetCDF file header contains the position of the data in
 |  the file, so access can be done in an efficient manner without loading
 |  unnecessary data into memory. It uses the ``mmap`` module to create
 |  Numpy arrays mapped to the data on disk, for the same purpose.
 |  
 |  Note that when `netcdf_file` is used to open a file with mmap=True
 |  (default for read-only), arrays returned by it refer to data
 |  directly on the disk. The file should not be closed, and cannot be cleanly
 |  closed when asked, if such arrays are alive. You may want to copy data arrays
 |  obtained from mmapped Netcdf file if they are to be processed after the file
 |  is closed, see the example below.
 |  
 |  Examples
 |  --------
 |  To create a NetCDF file:
 |  
 |  >>> from scipy.io import netcdf
 |  >>> f = netcdf.netcdf_file('simple.nc', 'w')
 |  >>> f.history = 'Created for a test'
 |  >>> f.createDimension('time', 10)
 |  >>> time = f.createVariable('time', 'i', ('time',))
 |  >>> time[:] = np.arange(10)
 |  >>> time.units = 'days since 2008-01-01'
 |  >>> f.close()
 |  
 |  Note the assignment of ``arange(10)`` to ``time[:]``.  Exposing the slice
 |  of the time variable allows for the data to be set in the object, rather
 |  than letting ``arange(10)`` overwrite the ``time`` variable.
 |  
 |  To read the NetCDF file we just created:
 |  
 |  >>> from scipy.io import netcdf
 |  >>> f = netcdf.netcdf_file('simple.nc', 'r')
 |  >>> print(f.history)
 |  b'Created for a test'
 |  >>> time = f.variables['time']
 |  >>> print(time.units)
 |  b'days since 2008-01-01'
 |  >>> print(time.shape)
 |  (10,)
 |  >>> print(time[-1])
 |  9
 |  
 |  NetCDF files, when opened read-only, return arrays that refer
 |  directly to memory-mapped data on disk:
 |  
 |  >>> data = time[:]
 |  >>> data.base.base
 |  <mmap.mmap object at 0x7fe753763180>
 |  
 |  If the data is to be processed after the file is closed, it needs
 |  to be copied to main memory:
 |  
 |  >>> data = time[:].copy()
 |  >>> f.close()
 |  >>> data.mean()
 |  4.5
 |  
 |  A NetCDF file can also be used as context manager:
 |  
 |  >>> from scipy.io import netcdf
 |  >>> with netcdf.netcdf_file('simple.nc', 'r') as f:
 |  ...     print(f.history)
 |  b'Created for a test'
 |  
 |  Methods defined here:
 |  
 |  __del__ = close(self)
 |  
 |  __enter__(self)
 |  
 |  __exit__(self, type, value, traceback)
 |  
 |  __init__(self, filename, mode='r', mmap=None, version=1, maskandscale=False)
 |      Initialize netcdf_file from fileobj (str or file-like).
 |  
 |  __setattr__(self, attr, value)
 |      Implement setattr(self, name, value).
 |  
 |  close(self)
 |      Closes the NetCDF file.
 |  
 |  createDimension(self, name, length)
 |      Adds a dimension to the Dimension section of the NetCDF data structure.
 |      
 |      Note that this function merely adds a new dimension that the variables can
 |      reference.  The values for the dimension, if desired, should be added as
 |      a variable using `createVariable`, referring to this dimension.
 |      
 |      Parameters
 |      ----------
 |      name : str
 |          Name of the dimension (Eg, 'lat' or 'time').
 |      length : int
 |          Length of the dimension.
 |      
 |      See Also
 |      --------
 |      createVariable
 |  
 |  createVariable(self, name, type, dimensions)
 |      Create an empty variable for the `netcdf_file` object, specifying its data
 |      type and the dimensions it uses.
 |      
 |      Parameters
 |      ----------
 |      name : str
 |          Name of the new variable.
 |      type : dtype or str
 |          Data type of the variable.
 |      dimensions : sequence of str
 |          List of the dimension names used by the variable, in the desired order.
 |      
 |      Returns
 |      -------
 |      variable : netcdf_variable
 |          The newly created ``netcdf_variable`` object.
 |          This object has also been added to the `netcdf_file` object as well.
 |      
 |      See Also
 |      --------
 |      createDimension
 |      
 |      Notes
 |      -----
 |      Any dimensions to be used by the variable should already exist in the
 |      NetCDF data structure or should be created by `createDimension` prior to
 |      creating the NetCDF variable.
 |  
 |  flush(self)
 |      Perform a sync-to-disk flush if the `netcdf_file` object is in write mode.
 |      
 |      See Also
 |      --------
 |      sync : Identical function
 |  
 |  sync = flush(self)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"(""(self, filename, mode='r', mmap=None, version=1, maskandscale=False)"",)",scipy,1.1.0,scipy.io.netcdf_file,io,netcdf_file,"Python Library Documentation: class netcdf_file in module scipy.io.netcdf

class netcdf_file(builtins.object)
 |  A file object for NetCDF data.
 |  
 |  A `netcdf_file` object has two standard attributes: `dimensions` and
 |  `variables`. The values of both are dictionaries, mapping dimension
 |  names to their associated lengths and variable names to variables,
 |  respectively. Application programs should never modify these
 |  dictionaries.
 |  
 |  All other attributes correspond to global attributes defined in the
 |  NetCDF file. Global file attributes are created by assigning to an
 |  attribute of the `netcdf_file` object.
 |  
 |  Parameters
 |  ----------
 |  filename : string or file-like
 |      string -> filename
 |  mode : {'r', 'w', 'a'}, optional
 |      read-write-append mode, default is 'r'
 |  mmap : None or bool, optional
 |      Whether to mmap `filename` when reading.  Default is True
 |      when `filename` is a file name, False when `filename` is a
 |      file-like object. Note that when mmap is in use, data arrays
 |      returned refer directly to the mmapped data on disk, and the
 |      file cannot be closed as long as references to it exist.
 |  version : {1, 2}, optional
 |      version of netcdf to read / write, where 1 means *Classic
 |      format* and 2 means *64-bit offset format*.  Default is 1.  See
 |      `here <https://www.unidata.ucar.edu/software/netcdf/docs/netcdf_introduction.html#select_format>`__
 |      for more info.
 |  maskandscale : bool, optional
 |      Whether to automatically scale and/or mask data based on attributes.
 |      Default is False.
 |  
 |  Notes
 |  -----
 |  The major advantage of this module over other modules is that it doesn't
 |  require the code to be linked to the NetCDF libraries. This module is
 |  derived from `pupynere <https://bitbucket.org/robertodealmeida/pupynere/>`_.
 |  
 |  NetCDF files are a self-describing binary data format. The file contains
 |  metadata that describes the dimensions and variables in the file. More
 |  details about NetCDF files can be found `here
 |  <https://www.unidata.ucar.edu/software/netcdf/docs/user_guide.html>`__. There
 |  are three main sections to a NetCDF data structure:
 |  
 |  1. Dimensions
 |  2. Variables
 |  3. Attributes
 |  
 |  The dimensions section records the name and length of each dimension used
 |  by the variables. The variables would then indicate which dimensions it
 |  uses and any attributes such as data units, along with containing the data
 |  values for the variable. It is good practice to include a
 |  variable that is the same name as a dimension to provide the values for
 |  that axes. Lastly, the attributes section would contain additional
 |  information such as the name of the file creator or the instrument used to
 |  collect the data.
 |  
 |  When writing data to a NetCDF file, there is often the need to indicate the
 |  'record dimension'. A record dimension is the unbounded dimension for a
 |  variable. For example, a temperature variable may have dimensions of
 |  latitude, longitude and time. If one wants to add more temperature data to
 |  the NetCDF file as time progresses, then the temperature variable should
 |  have the time dimension flagged as the record dimension.
 |  
 |  In addition, the NetCDF file header contains the position of the data in
 |  the file, so access can be done in an efficient manner without loading
 |  unnecessary data into memory. It uses the ``mmap`` module to create
 |  Numpy arrays mapped to the data on disk, for the same purpose.
 |  
 |  Note that when `netcdf_file` is used to open a file with mmap=True
 |  (default for read-only), arrays returned by it refer to data
 |  directly on the disk. The file should not be closed, and cannot be cleanly
 |  closed when asked, if such arrays are alive. You may want to copy data arrays
 |  obtained from mmapped Netcdf file if they are to be processed after the file
 |  is closed, see the example below.
 |  
 |  Examples
 |  --------
 |  To create a NetCDF file:
 |  
 |  >>> from scipy.io import netcdf
 |  >>> f = netcdf.netcdf_file('simple.nc', 'w')
 |  >>> f.history = 'Created for a test'
 |  >>> f.createDimension('time', 10)
 |  >>> time = f.createVariable('time', 'i', ('time',))
 |  >>> time[:] = np.arange(10)
 |  >>> time.units = 'days since 2008-01-01'
 |  >>> f.close()
 |  
 |  Note the assignment of ``arange(10)`` to ``time[:]``.  Exposing the slice
 |  of the time variable allows for the data to be set in the object, rather
 |  than letting ``arange(10)`` overwrite the ``time`` variable.
 |  
 |  To read the NetCDF file we just created:
 |  
 |  >>> from scipy.io import netcdf
 |  >>> f = netcdf.netcdf_file('simple.nc', 'r')
 |  >>> print(f.history)
 |  b'Created for a test'
 |  >>> time = f.variables['time']
 |  >>> print(time.units)
 |  b'days since 2008-01-01'
 |  >>> print(time.shape)
 |  (10,)
 |  >>> print(time[-1])
 |  9
 |  
 |  NetCDF files, when opened read-only, return arrays that refer
 |  directly to memory-mapped data on disk:
 |  
 |  >>> data = time[:]
 |  >>> data.base.base
 |  <mmap.mmap object at 0x7fe753763180>
 |  
 |  If the data is to be processed after the file is closed, it needs
 |  to be copied to main memory:
 |  
 |  >>> data = time[:].copy()
 |  >>> f.close()
 |  >>> data.mean()
 |  4.5
 |  
 |  A NetCDF file can also be used as context manager:
 |  
 |  >>> from scipy.io import netcdf
 |  >>> with netcdf.netcdf_file('simple.nc', 'r') as f:
 |  ...     print(f.history)
 |  b'Created for a test'
 |  
 |  Methods defined here:
 |  
 |  __del__ = close(self)
 |  
 |  __enter__(self)
 |  
 |  __exit__(self, type, value, traceback)
 |  
 |  __init__(self, filename, mode='r', mmap=None, version=1, maskandscale=False)
 |      Initialize netcdf_file from fileobj (str or file-like).
 |  
 |  __setattr__(self, attr, value)
 |      Implement setattr(self, name, value).
 |  
 |  close(self)
 |      Closes the NetCDF file.
 |  
 |  createDimension(self, name, length)
 |      Adds a dimension to the Dimension section of the NetCDF data structure.
 |      
 |      Note that this function merely adds a new dimension that the variables can
 |      reference.  The values for the dimension, if desired, should be added as
 |      a variable using `createVariable`, referring to this dimension.
 |      
 |      Parameters
 |      ----------
 |      name : str
 |          Name of the dimension (Eg, 'lat' or 'time').
 |      length : int
 |          Length of the dimension.
 |      
 |      See Also
 |      --------
 |      createVariable
 |  
 |  createVariable(self, name, type, dimensions)
 |      Create an empty variable for the `netcdf_file` object, specifying its data
 |      type and the dimensions it uses.
 |      
 |      Parameters
 |      ----------
 |      name : str
 |          Name of the new variable.
 |      type : dtype or str
 |          Data type of the variable.
 |      dimensions : sequence of str
 |          List of the dimension names used by the variable, in the desired order.
 |      
 |      Returns
 |      -------
 |      variable : netcdf_variable
 |          The newly created ``netcdf_variable`` object.
 |          This object has also been added to the `netcdf_file` object as well.
 |      
 |      See Also
 |      --------
 |      createDimension
 |      
 |      Notes
 |      -----
 |      Any dimensions to be used by the variable should already exist in the
 |      NetCDF data structure or should be created by `createDimension` prior to
 |      creating the NetCDF variable.
 |  
 |  flush(self)
 |      Perform a sync-to-disk flush if the `netcdf_file` object is in write mode.
 |      
 |      See Also
 |      --------
 |      sync : Identical function
 |  
 |  sync = flush(self)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'filename', 'mode', 'mmap', 'version', 'maskandscale')","(nan, nan, 'r', None, 1, False)","(nan, nan, 'str', 'NoneType', 'int', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(self, filename, mode='r', mmap=None, version=1, maskandscale=False)"",)"
scipy,1.1.0,scipy.io.netcdf_variable,io,netcdf_variable,"Python Library Documentation: class netcdf_variable in module scipy.io.netcdf

class netcdf_variable(builtins.object)
 |  A data object for the `netcdf` module.
 |  
 |  `netcdf_variable` objects are constructed by calling the method
 |  `netcdf_file.createVariable` on the `netcdf_file` object. `netcdf_variable`
 |  objects behave much like array objects defined in numpy, except that their
 |  data resides in a file. Data is read by indexing and written by assigning
 |  to an indexed subset; the entire array can be accessed by the index ``[:]``
 |  or (for scalars) by using the methods `getValue` and `assignValue`.
 |  `netcdf_variable` objects also have attribute `shape` with the same meaning
 |  as for arrays, but the shape cannot be modified. There is another read-only
 |  attribute `dimensions`, whose value is the tuple of dimension names.
 |  
 |  All other attributes correspond to variable attributes defined in
 |  the NetCDF file. Variable attributes are created by assigning to an
 |  attribute of the `netcdf_variable` object.
 |  
 |  Parameters
 |  ----------
 |  data : array_like
 |      The data array that holds the values for the variable.
 |      Typically, this is initialized as empty, but with the proper shape.
 |  typecode : dtype character code
 |      Desired data-type for the data array.
 |  size : int
 |      Desired element size for the data array.
 |  shape : sequence of ints
 |      The shape of the array.  This should match the lengths of the
 |      variable's dimensions.
 |  dimensions : sequence of strings
 |      The names of the dimensions used by the variable.  Must be in the
 |      same order of the dimension lengths given by `shape`.
 |  attributes : dict, optional
 |      Attribute values (any type) keyed by string names.  These attributes
 |      become attributes for the netcdf_variable object.
 |  maskandscale : bool, optional
 |      Whether to automatically scale and/or mask data based on attributes.
 |      Default is False.
 |  
 |  
 |  Attributes
 |  ----------
 |  dimensions : list of str
 |      List of names of dimensions used by the variable object.
 |  isrec, shape
 |      Properties
 |  
 |  See also
 |  --------
 |  isrec, shape
 |  
 |  Methods defined here:
 |  
 |  __getitem__(self, index)
 |  
 |  __init__(self, data, typecode, size, shape, dimensions, attributes=None, maskandscale=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __setattr__(self, attr, value)
 |      Implement setattr(self, name, value).
 |  
 |  __setitem__(self, index, data)
 |  
 |  assignValue(self, value)
 |      Assign a scalar value to a `netcdf_variable` of length one.
 |      
 |      Parameters
 |      ----------
 |      value : scalar
 |          Scalar value (of compatible type) to assign to a length-one netcdf
 |          variable. This value will be written to file.
 |      
 |      Raises
 |      ------
 |      ValueError
 |          If the input is not a scalar, or if the destination is not a length-one
 |          netcdf variable.
 |  
 |  getValue(self)
 |      Retrieve a scalar value from a `netcdf_variable` of length one.
 |      
 |      Raises
 |      ------
 |      ValueError
 |          If the netcdf variable is an array of length greater than one,
 |          this exception will be raised.
 |  
 |  itemsize(self)
 |      Return the itemsize of the variable.
 |      
 |      Returns
 |      -------
 |      itemsize : int
 |          The element size of the variable (eg, 8 for float64).
 |  
 |  typecode(self)
 |      Return the typecode of the variable.
 |      
 |      Returns
 |      -------
 |      typecode : char
 |          The character typecode of the variable (eg, 'i' for int).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  isrec
 |      Returns whether the variable has a record dimension or not.
 |      
 |      A record dimension is a dimension along which additional data could be
 |      easily appended in the netcdf data structure without much rewriting of
 |      the data file. This attribute is a read-only property of the
 |      `netcdf_variable`.
 |  
 |  shape
 |      Returns the shape tuple of the data variable.
 |      
 |      This is a read-only attribute and can not be modified in the
 |      same manner of other numpy arrays.
",class,"('(self, data, typecode, size, shape, dimensions, attributes=None, maskandscale=False)',)",scipy,1.1.0,scipy.io.netcdf_variable,io,netcdf_variable,"Python Library Documentation: class netcdf_variable in module scipy.io.netcdf

class netcdf_variable(builtins.object)
 |  A data object for the `netcdf` module.
 |  
 |  `netcdf_variable` objects are constructed by calling the method
 |  `netcdf_file.createVariable` on the `netcdf_file` object. `netcdf_variable`
 |  objects behave much like array objects defined in numpy, except that their
 |  data resides in a file. Data is read by indexing and written by assigning
 |  to an indexed subset; the entire array can be accessed by the index ``[:]``
 |  or (for scalars) by using the methods `getValue` and `assignValue`.
 |  `netcdf_variable` objects also have attribute `shape` with the same meaning
 |  as for arrays, but the shape cannot be modified. There is another read-only
 |  attribute `dimensions`, whose value is the tuple of dimension names.
 |  
 |  All other attributes correspond to variable attributes defined in
 |  the NetCDF file. Variable attributes are created by assigning to an
 |  attribute of the `netcdf_variable` object.
 |  
 |  Parameters
 |  ----------
 |  data : array_like
 |      The data array that holds the values for the variable.
 |      Typically, this is initialized as empty, but with the proper shape.
 |  typecode : dtype character code
 |      Desired data-type for the data array.
 |  size : int
 |      Desired element size for the data array.
 |  shape : sequence of ints
 |      The shape of the array.  This should match the lengths of the
 |      variable's dimensions.
 |  dimensions : sequence of strings
 |      The names of the dimensions used by the variable.  Must be in the
 |      same order of the dimension lengths given by `shape`.
 |  attributes : dict, optional
 |      Attribute values (any type) keyed by string names.  These attributes
 |      become attributes for the netcdf_variable object.
 |  maskandscale : bool, optional
 |      Whether to automatically scale and/or mask data based on attributes.
 |      Default is False.
 |  
 |  
 |  Attributes
 |  ----------
 |  dimensions : list of str
 |      List of names of dimensions used by the variable object.
 |  isrec, shape
 |      Properties
 |  
 |  See also
 |  --------
 |  isrec, shape
 |  
 |  Methods defined here:
 |  
 |  __getitem__(self, index)
 |  
 |  __init__(self, data, typecode, size, shape, dimensions, attributes=None, maskandscale=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __setattr__(self, attr, value)
 |      Implement setattr(self, name, value).
 |  
 |  __setitem__(self, index, data)
 |  
 |  assignValue(self, value)
 |      Assign a scalar value to a `netcdf_variable` of length one.
 |      
 |      Parameters
 |      ----------
 |      value : scalar
 |          Scalar value (of compatible type) to assign to a length-one netcdf
 |          variable. This value will be written to file.
 |      
 |      Raises
 |      ------
 |      ValueError
 |          If the input is not a scalar, or if the destination is not a length-one
 |          netcdf variable.
 |  
 |  getValue(self)
 |      Retrieve a scalar value from a `netcdf_variable` of length one.
 |      
 |      Raises
 |      ------
 |      ValueError
 |          If the netcdf variable is an array of length greater than one,
 |          this exception will be raised.
 |  
 |  itemsize(self)
 |      Return the itemsize of the variable.
 |      
 |      Returns
 |      -------
 |      itemsize : int
 |          The element size of the variable (eg, 8 for float64).
 |  
 |  typecode(self)
 |      Return the typecode of the variable.
 |      
 |      Returns
 |      -------
 |      typecode : char
 |          The character typecode of the variable (eg, 'i' for int).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  isrec
 |      Returns whether the variable has a record dimension or not.
 |      
 |      A record dimension is a dimension along which additional data could be
 |      easily appended in the netcdf data structure without much rewriting of
 |      the data file. This attribute is a read-only property of the
 |      `netcdf_variable`.
 |  
 |  shape
 |      Returns the shape tuple of the data variable.
 |      
 |      This is a read-only attribute and can not be modified in the
 |      same manner of other numpy arrays.
",class,"('self', 'data', 'typecode', 'size', 'shape', 'dimensions', 'attributes', 'maskandscale')","(nan, nan, nan, nan, nan, nan, None, False)","(nan, nan, nan, nan, nan, nan, 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(self, data, typecode, size, shape, dimensions, attributes=None, maskandscale=False)',)"
scipy,1.1.0,scipy.io.readsav,io,readsav,"Python Library Documentation: function readsav in module scipy.io.idl

readsav(file_name, idict=None, python_dict=False, uncompressed_file_name=None, verbose=False)
    Read an IDL .sav file.
    
    Parameters
    ----------
    file_name : str
        Name of the IDL save file.
    idict : dict, optional
        Dictionary in which to insert .sav file variables.
    python_dict : bool, optional
        By default, the object return is not a Python dictionary, but a
        case-insensitive dictionary with item, attribute, and call access
        to variables. To get a standard Python dictionary, set this option
        to True.
    uncompressed_file_name : str, optional
        This option only has an effect for .sav files written with the
        /compress option. If a file name is specified, compressed .sav
        files are uncompressed to this file. Otherwise, readsav will use
        the `tempfile` module to determine a temporary filename
        automatically, and will remove the temporary file upon successfully
        reading it in.
    verbose : bool, optional
        Whether to print out information about the save file, including
        the records read, and available variables.
    
    Returns
    -------
    idl_dict : AttrDict or dict
        If `python_dict` is set to False (default), this function returns a
        case-insensitive dictionary with item, attribute, and call access
        to variables. If `python_dict` is set to True, this function
        returns a Python dictionary with all variable names in lowercase.
        If `idict` was specified, then variables are written to the
        dictionary specified, and the updated dictionary is returned.
",function,"('(file_name, idict=None, python_dict=False, uncompressed_file_name=None, verbose=False)',)",scipy,1.1.0,scipy.io.readsav,io,readsav,"Python Library Documentation: function readsav in module scipy.io.idl

readsav(file_name, idict=None, python_dict=False, uncompressed_file_name=None, verbose=False)
    Read an IDL .sav file.
    
    Parameters
    ----------
    file_name : str
        Name of the IDL save file.
    idict : dict, optional
        Dictionary in which to insert .sav file variables.
    python_dict : bool, optional
        By default, the object return is not a Python dictionary, but a
        case-insensitive dictionary with item, attribute, and call access
        to variables. To get a standard Python dictionary, set this option
        to True.
    uncompressed_file_name : str, optional
        This option only has an effect for .sav files written with the
        /compress option. If a file name is specified, compressed .sav
        files are uncompressed to this file. Otherwise, readsav will use
        the `tempfile` module to determine a temporary filename
        automatically, and will remove the temporary file upon successfully
        reading it in.
    verbose : bool, optional
        Whether to print out information about the save file, including
        the records read, and available variables.
    
    Returns
    -------
    idl_dict : AttrDict or dict
        If `python_dict` is set to False (default), this function returns a
        case-insensitive dictionary with item, attribute, and call access
        to variables. If `python_dict` is set to True, this function
        returns a Python dictionary with all variable names in lowercase.
        If `idict` was specified, then variables are written to the
        dictionary specified, and the updated dictionary is returned.
",function,"('file_name', 'idict', 'python_dict', 'uncompressed_file_name', 'verbose')","(nan, None, False, None, False)","(nan, 'NoneType', 'bool', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(file_name, idict=None, python_dict=False, uncompressed_file_name=None, verbose=False)',)"
scipy,1.1.0,scipy.io.savemat,io,savemat,"Python Library Documentation: function savemat in module scipy.io.matlab.mio

savemat(file_name, mdict, appendmat=True, format='5', long_field_names=False, do_compression=False, oned_as='row')
    Save a dictionary of names and arrays into a MATLAB-style .mat file.
    
    This saves the array objects in the given dictionary to a MATLAB-
    style .mat file.
    
    Parameters
    ----------
    file_name : str or file-like object
        Name of the .mat file (.mat extension not needed if ``appendmat ==
        True``).
        Can also pass open file_like object.
    mdict : dict
        Dictionary from which to save matfile variables.
    appendmat : bool, optional
        True (the default) to append the .mat extension to the end of the
        given filename, if not already present.
    format : {'5', '4'}, string, optional
        '5' (the default) for MATLAB 5 and up (to 7.2),
        '4' for MATLAB 4 .mat files.
    long_field_names : bool, optional
        False (the default) - maximum field name length in a structure is
        31 characters which is the documented maximum length.
        True - maximum field name length in a structure is 63 characters
        which works for MATLAB 7.6+.
    do_compression : bool, optional
        Whether or not to compress matrices on write.  Default is False.
    oned_as : {'row', 'column'}, optional
        If 'column', write 1-D numpy arrays as column vectors.
        If 'row', write 1-D numpy arrays as row vectors.
    
    See also
    --------
    mio4.MatFile4Writer
    mio5.MatFile5Writer
",function,"(""(file_name, mdict, appendmat=True, format='5', long_field_names=False, do_compression=False, oned_as='row')"",)",scipy,1.1.0,scipy.io.savemat,io,savemat,"Python Library Documentation: function savemat in module scipy.io.matlab.mio

savemat(file_name, mdict, appendmat=True, format='5', long_field_names=False, do_compression=False, oned_as='row')
    Save a dictionary of names and arrays into a MATLAB-style .mat file.
    
    This saves the array objects in the given dictionary to a MATLAB-
    style .mat file.
    
    Parameters
    ----------
    file_name : str or file-like object
        Name of the .mat file (.mat extension not needed if ``appendmat ==
        True``).
        Can also pass open file_like object.
    mdict : dict
        Dictionary from which to save matfile variables.
    appendmat : bool, optional
        True (the default) to append the .mat extension to the end of the
        given filename, if not already present.
    format : {'5', '4'}, string, optional
        '5' (the default) for MATLAB 5 and up (to 7.2),
        '4' for MATLAB 4 .mat files.
    long_field_names : bool, optional
        False (the default) - maximum field name length in a structure is
        31 characters which is the documented maximum length.
        True - maximum field name length in a structure is 63 characters
        which works for MATLAB 7.6+.
    do_compression : bool, optional
        Whether or not to compress matrices on write.  Default is False.
    oned_as : {'row', 'column'}, optional
        If 'column', write 1-D numpy arrays as column vectors.
        If 'row', write 1-D numpy arrays as row vectors.
    
    See also
    --------
    mio4.MatFile4Writer
    mio5.MatFile5Writer
",function,"('file_name', 'mdict', 'appendmat', 'format', 'long_field_names', 'do_compression', 'oned_as')","(nan, nan, True, '5', False, False, 'row')","(nan, nan, 'bool', 'int', 'bool', 'bool', 'str')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(file_name, mdict, appendmat=True, format='5', long_field_names=False, do_compression=False, oned_as='row')"",)"
scipy,1.1.0,scipy.io.whosmat,io,whosmat,"Python Library Documentation: function whosmat in module scipy.io.matlab.mio

whosmat(file_name, appendmat=True, **kwargs)
    List variables inside a MATLAB file.
    
    Parameters
    ----------
    file_name : str
       Name of the mat file (do not need .mat extension if
       appendmat==True) Can also pass open file-like object.
    appendmat : bool, optional
       True to append the .mat extension to the end of the given
       filename, if not already present.
    byte_order : str or None, optional
       None by default, implying byte order guessed from mat
       file. Otherwise can be one of ('native', '=', 'little', '<',
       'BIG', '>').
    mat_dtype : bool, optional
       If True, return arrays in same dtype as would be loaded into
       MATLAB (instead of the dtype with which they are saved).
    squeeze_me : bool, optional
       Whether to squeeze unit matrix dimensions or not.
    chars_as_strings : bool, optional
       Whether to convert char arrays to string arrays.
    matlab_compatible : bool, optional
       Returns matrices as would be loaded by MATLAB (implies
       squeeze_me=False, chars_as_strings=False, mat_dtype=True,
       struct_as_record=True).
    struct_as_record : bool, optional
       Whether to load MATLAB structs as numpy record arrays, or as
       old-style numpy arrays with dtype=object.  Setting this flag to
       False replicates the behavior of scipy version 0.7.x (returning
       numpy object arrays).  The default setting is True, because it
       allows easier round-trip load and save of MATLAB files.
    
    Returns
    -------
    variables : list of tuples
        A list of tuples, where each tuple holds the matrix name (a string),
        its shape (tuple of ints), and its data class (a string).
        Possible data classes are: int8, uint8, int16, uint16, int32, uint32,
        int64, uint64, single, double, cell, struct, object, char, sparse,
        function, opaque, logical, unknown.
    
    Notes
    -----
    v4 (Level 1.0), v6 and v7 to 7.2 matfiles are supported.
    
    You will need an HDF5 python library to read matlab 7.3 format mat
    files.  Because scipy does not supply one, we do not implement the
    HDF5 / 7.3 interface here.
    
    .. versionadded:: 0.12.0
",function,"('(file_name, appendmat=True, **kwargs)',)",scipy,1.1.0,scipy.io.whosmat,io,whosmat,"Python Library Documentation: function whosmat in module scipy.io.matlab.mio

whosmat(file_name, appendmat=True, **kwargs)
    List variables inside a MATLAB file.
    
    Parameters
    ----------
    file_name : str
       Name of the mat file (do not need .mat extension if
       appendmat==True) Can also pass open file-like object.
    appendmat : bool, optional
       True to append the .mat extension to the end of the given
       filename, if not already present.
    byte_order : str or None, optional
       None by default, implying byte order guessed from mat
       file. Otherwise can be one of ('native', '=', 'little', '<',
       'BIG', '>').
    mat_dtype : bool, optional
       If True, return arrays in same dtype as would be loaded into
       MATLAB (instead of the dtype with which they are saved).
    squeeze_me : bool, optional
       Whether to squeeze unit matrix dimensions or not.
    chars_as_strings : bool, optional
       Whether to convert char arrays to string arrays.
    matlab_compatible : bool, optional
       Returns matrices as would be loaded by MATLAB (implies
       squeeze_me=False, chars_as_strings=False, mat_dtype=True,
       struct_as_record=True).
    struct_as_record : bool, optional
       Whether to load MATLAB structs as numpy record arrays, or as
       old-style numpy arrays with dtype=object.  Setting this flag to
       False replicates the behavior of scipy version 0.7.x (returning
       numpy object arrays).  The default setting is True, because it
       allows easier round-trip load and save of MATLAB files.
    
    Returns
    -------
    variables : list of tuples
        A list of tuples, where each tuple holds the matrix name (a string),
        its shape (tuple of ints), and its data class (a string).
        Possible data classes are: int8, uint8, int16, uint16, int32, uint32,
        int64, uint64, single, double, cell, struct, object, char, sparse,
        function, opaque, logical, unknown.
    
    Notes
    -----
    v4 (Level 1.0), v6 and v7 to 7.2 matfiles are supported.
    
    You will need an HDF5 python library to read matlab 7.3 format mat
    files.  Because scipy does not supply one, we do not implement the
    HDF5 / 7.3 interface here.
    
    .. versionadded:: 0.12.0
",function,"('file_name', 'appendmat')","(nan, True)","(nan, 'bool')","('arg_info', 'arg_info')","('(file_name, appendmat=True, **kwargs)',)"
scipy,1.1.0,scipy.linalg.LinAlgError,linalg,LinAlgError,"Python Library Documentation: class LinAlgError in module numpy.linalg.linalg

class LinAlgError(builtins.Exception)
 |  Generic Python-exception-derived object raised by linalg functions.
 |  
 |  General purpose exception class, derived from Python's exception.Exception
 |  class, programmatically raised in linalg functions when a Linear
 |  Algebra-related condition would prevent further correct execution of the
 |  function.
 |  
 |  Parameters
 |  ----------
 |  None
 |  
 |  Examples
 |  --------
 |  >>> from numpy import linalg as LA
 |  >>> LA.inv(np.zeros((2,2)))
 |  Traceback (most recent call last):
 |    File ""<stdin>"", line 1, in <module>
 |    File ""...linalg.py"", line 350,
 |      in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
 |    File ""...linalg.py"", line 249,
 |      in solve
 |      raise LinAlgError('Singular matrix')
 |  numpy.linalg.LinAlgError: Singular matrix
 |  
 |  Method resolution order:
 |      LinAlgError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg.LinAlgError,linalg,LinAlgError,"Python Library Documentation: class LinAlgError in module numpy.linalg.linalg

class LinAlgError(builtins.Exception)
 |  Generic Python-exception-derived object raised by linalg functions.
 |  
 |  General purpose exception class, derived from Python's exception.Exception
 |  class, programmatically raised in linalg functions when a Linear
 |  Algebra-related condition would prevent further correct execution of the
 |  function.
 |  
 |  Parameters
 |  ----------
 |  None
 |  
 |  Examples
 |  --------
 |  >>> from numpy import linalg as LA
 |  >>> LA.inv(np.zeros((2,2)))
 |  Traceback (most recent call last):
 |    File ""<stdin>"", line 1, in <module>
 |    File ""...linalg.py"", line 350,
 |      in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
 |    File ""...linalg.py"", line 249,
 |      in solve
 |      raise LinAlgError('Singular matrix')
 |  numpy.linalg.LinAlgError: Singular matrix
 |  
 |  Method resolution order:
 |      LinAlgError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg.LinAlgWarning,linalg,LinAlgWarning,"Python Library Documentation: class LinAlgWarning in module scipy.linalg.misc

class LinAlgWarning(builtins.RuntimeWarning)
 |  The warning emitted when a linear algebra related operation is close
 |  to fail conditions of the algorithm or loss of accuracy is expected.
 |  
 |  Method resolution order:
 |      LinAlgWarning
 |      builtins.RuntimeWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.RuntimeWarning:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg.LinAlgWarning,linalg,LinAlgWarning,"Python Library Documentation: class LinAlgWarning in module scipy.linalg.misc

class LinAlgWarning(builtins.RuntimeWarning)
 |  The warning emitted when a linear algebra related operation is close
 |  to fail conditions of the algorithm or loss of accuracy is expected.
 |  
 |  Method resolution order:
 |      LinAlgWarning
 |      builtins.RuntimeWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.RuntimeWarning:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg._decomp_ldl.ComplexWarning,linalg._decomp_ldl,ComplexWarning,"Python Library Documentation: class ComplexWarning in module numpy.core.numeric

class ComplexWarning(builtins.RuntimeWarning)
 |  The warning raised when casting a complex dtype to a real dtype.
 |  
 |  As implemented, casting a complex number to a real discards its imaginary
 |  part, but this behavior may not be what the user actually wants.
 |  
 |  Method resolution order:
 |      ComplexWarning
 |      builtins.RuntimeWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.RuntimeWarning:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg._decomp_ldl.ComplexWarning,linalg._decomp_ldl,ComplexWarning,"Python Library Documentation: class ComplexWarning in module numpy.core.numeric

class ComplexWarning(builtins.RuntimeWarning)
 |  The warning raised when casting a complex dtype to a real dtype.
 |  
 |  As implemented, casting a complex number to a real discards its imaginary
 |  part, but this behavior may not be what the user actually wants.
 |  
 |  Method resolution order:
 |      ComplexWarning
 |      builtins.RuntimeWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.RuntimeWarning:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg._decomp_ldl._asarray_validated,linalg._decomp_ldl,_asarray_validated,"Python Library Documentation: function _asarray_validated in module scipy._lib._util

_asarray_validated(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)
    Helper function for scipy argument validation.
    
    Many scipy linear algebra functions do support arbitrary array-like
    input arguments.  Examples of commonly unsupported inputs include
    matrices containing inf/nan, sparse matrix representations, and
    matrices with complicated elements.
    
    Parameters
    ----------
    a : array_like
        The array-like input.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default: True
    sparse_ok : bool, optional
        True if scipy sparse matrices are allowed.
    objects_ok : bool, optional
        True if arrays with dype('O') are allowed.
    mask_ok : bool, optional
        True if masked arrays are allowed.
    as_inexact : bool, optional
        True to convert the input array to a np.inexact dtype.
    
    Returns
    -------
    ret : ndarray
        The converted validated array.
",function,"('(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)',)",scipy,1.1.0,scipy.linalg._decomp_ldl._asarray_validated,linalg._decomp_ldl,_asarray_validated,"Python Library Documentation: function _asarray_validated in module scipy._lib._util

_asarray_validated(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)
    Helper function for scipy argument validation.
    
    Many scipy linear algebra functions do support arbitrary array-like
    input arguments.  Examples of commonly unsupported inputs include
    matrices containing inf/nan, sparse matrix representations, and
    matrices with complicated elements.
    
    Parameters
    ----------
    a : array_like
        The array-like input.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default: True
    sparse_ok : bool, optional
        True if scipy sparse matrices are allowed.
    objects_ok : bool, optional
        True if arrays with dype('O') are allowed.
    mask_ok : bool, optional
        True if masked arrays are allowed.
    as_inexact : bool, optional
        True to convert the input array to a np.inexact dtype.
    
    Returns
    -------
    ret : ndarray
        The converted validated array.
",function,"('a', 'check_finite', 'sparse_ok', 'objects_ok', 'mask_ok', 'as_inexact')","(nan, True, False, False, False, False)","(nan, 'bool', 'bool', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)',)"
scipy,1.1.0,scipy.linalg._decomp_ldl._compute_lwork,linalg._decomp_ldl,_compute_lwork,"Python Library Documentation: function _compute_lwork in module scipy.linalg.lapack

_compute_lwork(routine, *args, **kwargs)
    Round floating-point lwork returned by lapack to integer.
    
    Several LAPACK routines compute optimal values for LWORK, which
    they return in a floating-point variable. However, for large
    values of LWORK, single-precision floating point is not sufficient
    to hold the exact value --- some LAPACK versions (<= 3.5.0 at
    least) truncate the returned integer to single precision and in
    some cases this can be smaller than the required value.
    
    Examples
    --------
    >>> from scipy.linalg import lapack
    >>> n = 5000
    >>> s_r, s_lw = lapack.get_lapack_funcs(('sysvx', 'sysvx_lwork'))
    >>> lwork = lapack._compute_lwork(s_lw, n)
    >>> lwork
    32000
",function,"('(routine, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg._decomp_ldl._compute_lwork,linalg._decomp_ldl,_compute_lwork,"Python Library Documentation: function _compute_lwork in module scipy.linalg.lapack

_compute_lwork(routine, *args, **kwargs)
    Round floating-point lwork returned by lapack to integer.
    
    Several LAPACK routines compute optimal values for LWORK, which
    they return in a floating-point variable. However, for large
    values of LWORK, single-precision floating point is not sufficient
    to hold the exact value --- some LAPACK versions (<= 3.5.0 at
    least) truncate the returned integer to single precision and in
    some cases this can be smaller than the required value.
    
    Examples
    --------
    >>> from scipy.linalg import lapack
    >>> n = 5000
    >>> s_r, s_lw = lapack.get_lapack_funcs(('sysvx', 'sysvx_lwork'))
    >>> lwork = lapack._compute_lwork(s_lw, n)
    >>> lwork
    32000
",function,"('routine',)","(nan,)","(nan,)","('arg_info',)","('(routine, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg._decomp_ldl._ldl_construct_tri_factor,linalg._decomp_ldl,_ldl_construct_tri_factor,"Python Library Documentation: function _ldl_construct_tri_factor in module scipy.linalg._decomp_ldl

_ldl_construct_tri_factor(lu, swap_vec, pivs, lower=True)
    Helper function to construct explicit outer factors of LDL factorization.
    
    If lower is True the permuted factors are multiplied as L(1)*L(2)*...*L(k).
    Otherwise, the permuted factors are multiplied as L(k)*...*L(2)*L(1). See
    LAPACK documentation for more details.
    
    Parameters
    ----------
    lu : ndarray
        The triangular array that is extracted from LAPACK routine call with
        ones on the diagonals.
    swap_vec : ndarray
        The array that defines the row swapping indices. If k'th entry is m
        then rows k,m are swapped. Notice that m'th entry is not necessarily
        k to avoid undoing the swapping.
    pivs : ndarray
        The array that defines the block diagonal structure returned by
        _ldl_sanitize_ipiv().
    lower : bool, optional
        The boolean to switch between lower and upper triangular structure.
    
    Returns
    -------
    lu : ndarray
        The square outer factor which satisfies the L * D * L.T = A
    perm : ndarray
        The permutation vector that brings the lu to the triangular form
    
    Notes
    -----
    Note that the original argument ""lu"" is overwritten.
",function,"('(lu, swap_vec, pivs, lower=True)',)",scipy,1.1.0,scipy.linalg._decomp_ldl._ldl_construct_tri_factor,linalg._decomp_ldl,_ldl_construct_tri_factor,"Python Library Documentation: function _ldl_construct_tri_factor in module scipy.linalg._decomp_ldl

_ldl_construct_tri_factor(lu, swap_vec, pivs, lower=True)
    Helper function to construct explicit outer factors of LDL factorization.
    
    If lower is True the permuted factors are multiplied as L(1)*L(2)*...*L(k).
    Otherwise, the permuted factors are multiplied as L(k)*...*L(2)*L(1). See
    LAPACK documentation for more details.
    
    Parameters
    ----------
    lu : ndarray
        The triangular array that is extracted from LAPACK routine call with
        ones on the diagonals.
    swap_vec : ndarray
        The array that defines the row swapping indices. If k'th entry is m
        then rows k,m are swapped. Notice that m'th entry is not necessarily
        k to avoid undoing the swapping.
    pivs : ndarray
        The array that defines the block diagonal structure returned by
        _ldl_sanitize_ipiv().
    lower : bool, optional
        The boolean to switch between lower and upper triangular structure.
    
    Returns
    -------
    lu : ndarray
        The square outer factor which satisfies the L * D * L.T = A
    perm : ndarray
        The permutation vector that brings the lu to the triangular form
    
    Notes
    -----
    Note that the original argument ""lu"" is overwritten.
",function,"('lu', 'swap_vec', 'pivs', 'lower')","(nan, nan, nan, True)","(nan, nan, nan, 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(lu, swap_vec, pivs, lower=True)',)"
scipy,1.1.0,scipy.linalg._decomp_ldl._ldl_get_d_and_l,linalg._decomp_ldl,_ldl_get_d_and_l,"Python Library Documentation: function _ldl_get_d_and_l in module scipy.linalg._decomp_ldl

_ldl_get_d_and_l(ldu, pivs, lower=True, hermitian=True)
    Helper function to extract the diagonal and triangular matrices for
    LDL.T factorization.
    
    Parameters
    ----------
    ldu : ndarray
        The compact output returned by the LAPACK routing
    pivs : ndarray
        The sanitized array of {0, 1, 2} denoting the sizes of the pivots. For
        every 2 there is a succeeding 0.
    lower : bool, optional
        If set to False, upper triangular part is considered.
    hermitian : bool, optional
        If set to False a symmetric complex array is assumed.
    
    Returns
    -------
    d : ndarray
        The block diagonal matrix.
    lu : ndarray
        The upper/lower triangular matrix
",function,"('(ldu, pivs, lower=True, hermitian=True)',)",scipy,1.1.0,scipy.linalg._decomp_ldl._ldl_get_d_and_l,linalg._decomp_ldl,_ldl_get_d_and_l,"Python Library Documentation: function _ldl_get_d_and_l in module scipy.linalg._decomp_ldl

_ldl_get_d_and_l(ldu, pivs, lower=True, hermitian=True)
    Helper function to extract the diagonal and triangular matrices for
    LDL.T factorization.
    
    Parameters
    ----------
    ldu : ndarray
        The compact output returned by the LAPACK routing
    pivs : ndarray
        The sanitized array of {0, 1, 2} denoting the sizes of the pivots. For
        every 2 there is a succeeding 0.
    lower : bool, optional
        If set to False, upper triangular part is considered.
    hermitian : bool, optional
        If set to False a symmetric complex array is assumed.
    
    Returns
    -------
    d : ndarray
        The block diagonal matrix.
    lu : ndarray
        The upper/lower triangular matrix
",function,"('ldu', 'pivs', 'lower', 'hermitian')","(nan, nan, True, True)","(nan, nan, 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(ldu, pivs, lower=True, hermitian=True)',)"
scipy,1.1.0,scipy.linalg._decomp_ldl._ldl_sanitize_ipiv,linalg._decomp_ldl,_ldl_sanitize_ipiv,"Python Library Documentation: function _ldl_sanitize_ipiv in module scipy.linalg._decomp_ldl

_ldl_sanitize_ipiv(a, lower=True)
    This helper function takes the rather strangely encoded permutation array
    returned by the LAPACK routines ?(HE/SY)TRF and converts it into
    regularized permutation and diagonal pivot size format.
    
    Since FORTRAN uses 1-indexing and LAPACK uses different start points for
    upper and lower formats there are certain offsets in the indices used
    below.
    
    Let's assume a result where the matrix is 6x6 and there are two 2x2
    and two 1x1 blocks reported by the routine. To ease the coding efforts,
    we still populate a 6-sized array and fill zeros as the following ::
    
        pivots = [2, 0, 2, 0, 1, 1]
    
    This denotes a diagonal matrix of the form ::
    
        [x x        ]
        [x x        ]
        [    x x    ]
        [    x x    ]
        [        x  ]
        [          x]
    
    In other words, we write 2 when the 2x2 block is first encountered and
    automatically write 0 to the next entry and skip the next spin of the
    loop. Thus, a separate counter or array appends to keep track of block
    sizes are avoided. If needed, zeros can be filtered out later without
    losing the block structure.
    
    Parameters
    ----------
    a : ndarray
        The permutation array ipiv returned by LAPACK
    lower : bool, optional
        The switch to select whether upper or lower triangle is chosen in
        the LAPACK call.
    
    Returns
    -------
    swap_ : ndarray
        The array that defines the row/column swap operations. For example,
        if row two is swapped with row four, the result is [0, 3, 2, 3].
    pivots : ndarray
        The array that defines the block diagonal structure as given above.
",function,"('(a, lower=True)',)",scipy,1.1.0,scipy.linalg._decomp_ldl._ldl_sanitize_ipiv,linalg._decomp_ldl,_ldl_sanitize_ipiv,"Python Library Documentation: function _ldl_sanitize_ipiv in module scipy.linalg._decomp_ldl

_ldl_sanitize_ipiv(a, lower=True)
    This helper function takes the rather strangely encoded permutation array
    returned by the LAPACK routines ?(HE/SY)TRF and converts it into
    regularized permutation and diagonal pivot size format.
    
    Since FORTRAN uses 1-indexing and LAPACK uses different start points for
    upper and lower formats there are certain offsets in the indices used
    below.
    
    Let's assume a result where the matrix is 6x6 and there are two 2x2
    and two 1x1 blocks reported by the routine. To ease the coding efforts,
    we still populate a 6-sized array and fill zeros as the following ::
    
        pivots = [2, 0, 2, 0, 1, 1]
    
    This denotes a diagonal matrix of the form ::
    
        [x x        ]
        [x x        ]
        [    x x    ]
        [    x x    ]
        [        x  ]
        [          x]
    
    In other words, we write 2 when the 2x2 block is first encountered and
    automatically write 0 to the next entry and skip the next spin of the
    loop. Thus, a separate counter or array appends to keep track of block
    sizes are avoided. If needed, zeros can be filtered out later without
    losing the block structure.
    
    Parameters
    ----------
    a : ndarray
        The permutation array ipiv returned by LAPACK
    lower : bool, optional
        The switch to select whether upper or lower triangle is chosen in
        the LAPACK call.
    
    Returns
    -------
    swap_ : ndarray
        The array that defines the row/column swap operations. For example,
        if row two is swapped with row four, the result is [0, 3, 2, 3].
    pivots : ndarray
        The array that defines the block diagonal structure as given above.
",function,"('a', 'lower')","(nan, True)","(nan, 'bool')","('arg_info', 'arg_info')","('(a, lower=True)',)"
scipy,1.1.0,scipy.linalg._decomp_ldl.argsort,linalg._decomp_ldl,argsort,"Python Library Documentation: function argsort in module numpy.core.fromnumeric

argsort(a, axis=-1, kind='quicksort', order=None)
    Returns the indices that would sort an array.
    
    Perform an indirect sort along the given axis using the algorithm specified
    by the `kind` keyword. It returns an array of indices of the same shape as
    `a` that index data along the given axis in sorted order.
    
    Parameters
    ----------
    a : array_like
        Array to sort.
    axis : int or None, optional
        Axis along which to sort.  The default is -1 (the last axis). If None,
        the flattened array is used.
    kind : {'quicksort', 'mergesort', 'heapsort'}, optional
        Sorting algorithm.
    order : str or list of str, optional
        When `a` is an array with fields defined, this argument specifies
        which fields to compare first, second, etc.  A single field can
        be specified as a string, and not all fields need be specified,
        but unspecified fields will still be used, in the order in which
        they come up in the dtype, to break ties.
    
    Returns
    -------
    index_array : ndarray, int
        Array of indices that sort `a` along the specified axis.
        If `a` is one-dimensional, ``a[index_array]`` yields a sorted `a`.
    
    See Also
    --------
    sort : Describes sorting algorithms used.
    lexsort : Indirect stable sort with multiple keys.
    ndarray.sort : Inplace sort.
    argpartition : Indirect partial sort.
    
    Notes
    -----
    See `sort` for notes on the different sorting algorithms.
    
    As of NumPy 1.4.0 `argsort` works with real/complex arrays containing
    nan values. The enhanced sort order is documented in `sort`.
    
    Examples
    --------
    One dimensional array:
    
    >>> x = np.array([3, 1, 2])
    >>> np.argsort(x)
    array([1, 2, 0])
    
    Two-dimensional array:
    
    >>> x = np.array([[0, 3], [2, 2]])
    >>> x
    array([[0, 3],
           [2, 2]])
    
    >>> np.argsort(x, axis=0)  # sorts along first axis (down)
    array([[0, 1],
           [1, 0]])
    
    >>> np.argsort(x, axis=1)  # sorts along last axis (across)
    array([[0, 1],
           [0, 1]])
    
    Indices of the sorted elements of a N-dimensional array:
    
    >>> ind = np.unravel_index(np.argsort(x, axis=None), x.shape)
    >>> ind
    (array([0, 1, 1, 0]), array([0, 0, 1, 1]))
    >>> x[ind]  # same as np.sort(x, axis=None)
    array([0, 2, 2, 3])
    
    Sorting with keys:
    
    >>> x = np.array([(1, 0), (0, 1)], dtype=[('x', '<i4'), ('y', '<i4')])
    >>> x
    array([(1, 0), (0, 1)],
          dtype=[('x', '<i4'), ('y', '<i4')])
    
    >>> np.argsort(x, order=('x','y'))
    array([1, 0])
    
    >>> np.argsort(x, order=('y','x'))
    array([0, 1])
",function,"(""(a, axis=-1, kind='quicksort', order=None)"",)",scipy,1.1.0,scipy.linalg._decomp_ldl.argsort,linalg._decomp_ldl,argsort,"Python Library Documentation: function argsort in module numpy.core.fromnumeric

argsort(a, axis=-1, kind='quicksort', order=None)
    Returns the indices that would sort an array.
    
    Perform an indirect sort along the given axis using the algorithm specified
    by the `kind` keyword. It returns an array of indices of the same shape as
    `a` that index data along the given axis in sorted order.
    
    Parameters
    ----------
    a : array_like
        Array to sort.
    axis : int or None, optional
        Axis along which to sort.  The default is -1 (the last axis). If None,
        the flattened array is used.
    kind : {'quicksort', 'mergesort', 'heapsort'}, optional
        Sorting algorithm.
    order : str or list of str, optional
        When `a` is an array with fields defined, this argument specifies
        which fields to compare first, second, etc.  A single field can
        be specified as a string, and not all fields need be specified,
        but unspecified fields will still be used, in the order in which
        they come up in the dtype, to break ties.
    
    Returns
    -------
    index_array : ndarray, int
        Array of indices that sort `a` along the specified axis.
        If `a` is one-dimensional, ``a[index_array]`` yields a sorted `a`.
    
    See Also
    --------
    sort : Describes sorting algorithms used.
    lexsort : Indirect stable sort with multiple keys.
    ndarray.sort : Inplace sort.
    argpartition : Indirect partial sort.
    
    Notes
    -----
    See `sort` for notes on the different sorting algorithms.
    
    As of NumPy 1.4.0 `argsort` works with real/complex arrays containing
    nan values. The enhanced sort order is documented in `sort`.
    
    Examples
    --------
    One dimensional array:
    
    >>> x = np.array([3, 1, 2])
    >>> np.argsort(x)
    array([1, 2, 0])
    
    Two-dimensional array:
    
    >>> x = np.array([[0, 3], [2, 2]])
    >>> x
    array([[0, 3],
           [2, 2]])
    
    >>> np.argsort(x, axis=0)  # sorts along first axis (down)
    array([[0, 1],
           [1, 0]])
    
    >>> np.argsort(x, axis=1)  # sorts along last axis (across)
    array([[0, 1],
           [0, 1]])
    
    Indices of the sorted elements of a N-dimensional array:
    
    >>> ind = np.unravel_index(np.argsort(x, axis=None), x.shape)
    >>> ind
    (array([0, 1, 1, 0]), array([0, 0, 1, 1]))
    >>> x[ind]  # same as np.sort(x, axis=None)
    array([0, 2, 2, 3])
    
    Sorting with keys:
    
    >>> x = np.array([(1, 0), (0, 1)], dtype=[('x', '<i4'), ('y', '<i4')])
    >>> x
    array([(1, 0), (0, 1)],
          dtype=[('x', '<i4'), ('y', '<i4')])
    
    >>> np.argsort(x, order=('x','y'))
    array([1, 0])
    
    >>> np.argsort(x, order=('y','x'))
    array([0, 1])
",function,"('a', 'axis', 'kind', 'order')","(nan, -1, 'quicksort', None)","(nan, 'int', 'str', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a, axis=-1, kind='quicksort', order=None)"",)"
scipy,1.1.0,scipy.linalg._decomp_ldl.atleast_2d,linalg._decomp_ldl,atleast_2d,"Python Library Documentation: function atleast_2d in module numpy.core.shape_base

atleast_2d(*arys)
    View inputs as arrays with at least two dimensions.
    
    Parameters
    ----------
    arys1, arys2, ... : array_like
        One or more array-like sequences.  Non-array inputs are converted
        to arrays.  Arrays that already have two or more dimensions are
        preserved.
    
    Returns
    -------
    res, res2, ... : ndarray
        An array, or list of arrays, each with ``a.ndim >= 2``.
        Copies are avoided where possible, and views with two or more
        dimensions are returned.
    
    See Also
    --------
    atleast_1d, atleast_3d
    
    Examples
    --------
    >>> np.atleast_2d(3.0)
    array([[ 3.]])
    
    >>> x = np.arange(3.0)
    >>> np.atleast_2d(x)
    array([[ 0.,  1.,  2.]])
    >>> np.atleast_2d(x).base is x
    True
    
    >>> np.atleast_2d(1, [1, 2], [[1, 2]])
    [array([[1]]), array([[1, 2]]), array([[1, 2]])]
",function,"('(*arys)',)",scipy,1.1.0,scipy.linalg._decomp_ldl.atleast_2d,linalg._decomp_ldl,atleast_2d,"Python Library Documentation: function atleast_2d in module numpy.core.shape_base

atleast_2d(*arys)
    View inputs as arrays with at least two dimensions.
    
    Parameters
    ----------
    arys1, arys2, ... : array_like
        One or more array-like sequences.  Non-array inputs are converted
        to arrays.  Arrays that already have two or more dimensions are
        preserved.
    
    Returns
    -------
    res, res2, ... : ndarray
        An array, or list of arrays, each with ``a.ndim >= 2``.
        Copies are avoided where possible, and views with two or more
        dimensions are returned.
    
    See Also
    --------
    atleast_1d, atleast_3d
    
    Examples
    --------
    >>> np.atleast_2d(3.0)
    array([[ 3.]])
    
    >>> x = np.arange(3.0)
    >>> np.atleast_2d(x)
    array([[ 0.,  1.,  2.]])
    >>> np.atleast_2d(x).base is x
    True
    
    >>> np.atleast_2d(1, [1, 2], [[1, 2]])
    [array([[1]]), array([[1, 2]]), array([[1, 2]])]
",function,(),(),(),(),"('(*arys)',)"
scipy,1.1.0,scipy.linalg._decomp_ldl.diag,linalg._decomp_ldl,diag,"Python Library Documentation: function diag in module numpy.lib.twodim_base

diag(v, k=0)
    Extract a diagonal or construct a diagonal array.
    
    See the more detailed documentation for ``numpy.diagonal`` if you use this
    function to extract a diagonal and wish to write to the resulting array;
    whether it returns a copy or a view depends on what version of numpy you
    are using.
    
    Parameters
    ----------
    v : array_like
        If `v` is a 2-D array, return a copy of its `k`-th diagonal.
        If `v` is a 1-D array, return a 2-D array with `v` on the `k`-th
        diagonal.
    k : int, optional
        Diagonal in question. The default is 0. Use `k>0` for diagonals
        above the main diagonal, and `k<0` for diagonals below the main
        diagonal.
    
    Returns
    -------
    out : ndarray
        The extracted diagonal or constructed diagonal array.
    
    See Also
    --------
    diagonal : Return specified diagonals.
    diagflat : Create a 2-D array with the flattened input as a diagonal.
    trace : Sum along diagonals.
    triu : Upper triangle of an array.
    tril : Lower triangle of an array.
    
    Examples
    --------
    >>> x = np.arange(9).reshape((3,3))
    >>> x
    array([[0, 1, 2],
           [3, 4, 5],
           [6, 7, 8]])
    
    >>> np.diag(x)
    array([0, 4, 8])
    >>> np.diag(x, k=1)
    array([1, 5])
    >>> np.diag(x, k=-1)
    array([3, 7])
    
    >>> np.diag(np.diag(x))
    array([[0, 0, 0],
           [0, 4, 0],
           [0, 0, 8]])
",function,"('(v, k=0)',)",scipy,1.1.0,scipy.linalg._decomp_ldl.diag,linalg._decomp_ldl,diag,"Python Library Documentation: function diag in module numpy.lib.twodim_base

diag(v, k=0)
    Extract a diagonal or construct a diagonal array.
    
    See the more detailed documentation for ``numpy.diagonal`` if you use this
    function to extract a diagonal and wish to write to the resulting array;
    whether it returns a copy or a view depends on what version of numpy you
    are using.
    
    Parameters
    ----------
    v : array_like
        If `v` is a 2-D array, return a copy of its `k`-th diagonal.
        If `v` is a 1-D array, return a 2-D array with `v` on the `k`-th
        diagonal.
    k : int, optional
        Diagonal in question. The default is 0. Use `k>0` for diagonals
        above the main diagonal, and `k<0` for diagonals below the main
        diagonal.
    
    Returns
    -------
    out : ndarray
        The extracted diagonal or constructed diagonal array.
    
    See Also
    --------
    diagonal : Return specified diagonals.
    diagflat : Create a 2-D array with the flattened input as a diagonal.
    trace : Sum along diagonals.
    triu : Upper triangle of an array.
    tril : Lower triangle of an array.
    
    Examples
    --------
    >>> x = np.arange(9).reshape((3,3))
    >>> x
    array([[0, 1, 2],
           [3, 4, 5],
           [6, 7, 8]])
    
    >>> np.diag(x)
    array([0, 4, 8])
    >>> np.diag(x, k=1)
    array([1, 5])
    >>> np.diag(x, k=-1)
    array([3, 7])
    
    >>> np.diag(np.diag(x))
    array([[0, 0, 0],
           [0, 4, 0],
           [0, 0, 8]])
",function,"('v', 'k')","(nan, 0)","(nan, 'int')","('arg_info', 'arg_info')","('(v, k=0)',)"
scipy,1.1.0,scipy.linalg._decomp_ldl.get_lapack_funcs,linalg._decomp_ldl,get_lapack_funcs,"Python Library Documentation: function get_lapack_funcs in module scipy.linalg.lapack

get_lapack_funcs(names, arrays=(), dtype=None)
    Return available LAPACK function objects from names.
    
    Arrays are used to determine the optimal prefix of LAPACK routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of LAPACK functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of LAPACK
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In LAPACK, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively, and
    are stored in attribute ``typecode`` of the returned functions.
    
    Examples
    --------
    Suppose we would like to use '?lange' routine which computes the selected
    norm of an array. We pass our array in order to get the correct 'lange'
    flavor.
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_lange = LA.get_lapack_funcs('lange', (a,))
    >>> x_lange.typecode
    'd'
    >>> x_lange = LA.get_lapack_funcs('lange',(a*1j,))
    >>> x_lange.typecode
    'z'
    
    Several LAPACK routines work best when its internal WORK array has
    the optimal size (big enough for fast computation and small enough to
    avoid waste of memory). This size is determined also by a dedicated query
    to the function which is often wrapped as a standalone function and
    commonly denoted as ``###_lwork``. Below is an example for ``?sysv``
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(1000,1000)
    >>> b = np.random.rand(1000,1)*1j
    >>> # We pick up zsysv and zsysv_lwork due to b array
    ... xsysv, xlwork = LA.get_lapack_funcs(('sysv', 'sysv_lwork'), (a, b))
    >>> opt_lwork, _ = xlwork(a.shape[0])  # returns a complex for 'z' prefix
    >>> udut, ipiv, x, info = xsysv(a, b, lwork=int(opt_lwork.real))
",function,"('(names, arrays=(), dtype=None)',)",scipy,1.1.0,scipy.linalg._decomp_ldl.get_lapack_funcs,linalg._decomp_ldl,get_lapack_funcs,"Python Library Documentation: function get_lapack_funcs in module scipy.linalg.lapack

get_lapack_funcs(names, arrays=(), dtype=None)
    Return available LAPACK function objects from names.
    
    Arrays are used to determine the optimal prefix of LAPACK routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of LAPACK functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of LAPACK
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In LAPACK, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively, and
    are stored in attribute ``typecode`` of the returned functions.
    
    Examples
    --------
    Suppose we would like to use '?lange' routine which computes the selected
    norm of an array. We pass our array in order to get the correct 'lange'
    flavor.
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_lange = LA.get_lapack_funcs('lange', (a,))
    >>> x_lange.typecode
    'd'
    >>> x_lange = LA.get_lapack_funcs('lange',(a*1j,))
    >>> x_lange.typecode
    'z'
    
    Several LAPACK routines work best when its internal WORK array has
    the optimal size (big enough for fast computation and small enough to
    avoid waste of memory). This size is determined also by a dedicated query
    to the function which is often wrapped as a standalone function and
    commonly denoted as ``###_lwork``. Below is an example for ``?sysv``
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(1000,1000)
    >>> b = np.random.rand(1000,1)*1j
    >>> # We pick up zsysv and zsysv_lwork due to b array
    ... xsysv, xlwork = LA.get_lapack_funcs(('sysv', 'sysv_lwork'), (a, b))
    >>> opt_lwork, _ = xlwork(a.shape[0])  # returns a complex for 'z' prefix
    >>> udut, ipiv, x, info = xsysv(a, b, lwork=int(opt_lwork.real))
",function,"('names', 'arrays', 'dtype')","(nan, (), None)","(nan, 'tuple', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(names, arrays=(), dtype=None)',)"
scipy,1.1.0,scipy.linalg._decomp_ldl.imag,linalg._decomp_ldl,imag,"Python Library Documentation: function imag in module numpy.lib.type_check

imag(val)
    Return the imaginary part of the complex argument.
    
    Parameters
    ----------
    val : array_like
        Input array.
    
    Returns
    -------
    out : ndarray or scalar
        The imaginary component of the complex argument. If `val` is real,
        the type of `val` is used for the output.  If `val` has complex
        elements, the returned type is float.
    
    See Also
    --------
    real, angle, real_if_close
    
    Examples
    --------
    >>> a = np.array([1+2j, 3+4j, 5+6j])
    >>> a.imag
    array([ 2.,  4.,  6.])
    >>> a.imag = np.array([8, 10, 12])
    >>> a
    array([ 1. +8.j,  3.+10.j,  5.+12.j])
    >>> np.imag(1 + 1j)
    1.0
",function,"('(val)',)",scipy,1.1.0,scipy.linalg._decomp_ldl.imag,linalg._decomp_ldl,imag,"Python Library Documentation: function imag in module numpy.lib.type_check

imag(val)
    Return the imaginary part of the complex argument.
    
    Parameters
    ----------
    val : array_like
        Input array.
    
    Returns
    -------
    out : ndarray or scalar
        The imaginary component of the complex argument. If `val` is real,
        the type of `val` is used for the output.  If `val` has complex
        elements, the returned type is float.
    
    See Also
    --------
    real, angle, real_if_close
    
    Examples
    --------
    >>> a = np.array([1+2j, 3+4j, 5+6j])
    >>> a.imag
    array([ 2.,  4.,  6.])
    >>> a.imag = np.array([8, 10, 12])
    >>> a
    array([ 1. +8.j,  3.+10.j,  5.+12.j])
    >>> np.imag(1 + 1j)
    1.0
",function,"('val',)","(nan,)","(nan,)","('arg_info',)","('(val)',)"
scipy,1.1.0,scipy.linalg._decomp_ldl.iscomplexobj,linalg._decomp_ldl,iscomplexobj,"Python Library Documentation: function iscomplexobj in module numpy.lib.type_check

iscomplexobj(x)
    Check for a complex type or an array of complex numbers.
    
    The type of the input is checked, not the value. Even if the input
    has an imaginary part equal to zero, `iscomplexobj` evaluates to True.
    
    Parameters
    ----------
    x : any
        The input can be of any type and shape.
    
    Returns
    -------
    iscomplexobj : bool
        The return value, True if `x` is of a complex type or has at least
        one complex element.
    
    See Also
    --------
    isrealobj, iscomplex
    
    Examples
    --------
    >>> np.iscomplexobj(1)
    False
    >>> np.iscomplexobj(1+0j)
    True
    >>> np.iscomplexobj([3, 1+0j, True])
    True
",function,"('(x)',)",scipy,1.1.0,scipy.linalg._decomp_ldl.iscomplexobj,linalg._decomp_ldl,iscomplexobj,"Python Library Documentation: function iscomplexobj in module numpy.lib.type_check

iscomplexobj(x)
    Check for a complex type or an array of complex numbers.
    
    The type of the input is checked, not the value. Even if the input
    has an imaginary part equal to zero, `iscomplexobj` evaluates to True.
    
    Parameters
    ----------
    x : any
        The input can be of any type and shape.
    
    Returns
    -------
    iscomplexobj : bool
        The return value, True if `x` is of a complex type or has at least
        one complex element.
    
    See Also
    --------
    isrealobj, iscomplex
    
    Examples
    --------
    >>> np.iscomplexobj(1)
    False
    >>> np.iscomplexobj(1+0j)
    True
    >>> np.iscomplexobj([3, 1+0j, True])
    True
",function,"('x',)","(nan,)","(nan,)","('arg_info',)","('(x)',)"
scipy,1.1.0,scipy.linalg._decomp_ldl.ldl,linalg._decomp_ldl,ldl,"Python Library Documentation: function ldl in module scipy.linalg._decomp_ldl

ldl(A, lower=True, hermitian=True, overwrite_a=False, check_finite=True)
    Computes the LDLt or Bunch-Kaufman factorization of a symmetric/
    hermitian matrix.
    
    This function returns a block diagonal matrix D consisting blocks of size
    at most 2x2 and also a possibly permuted unit lower triangular matrix
    ``L`` such that the factorization ``A = L D L^H`` or ``A = L D L^T``
    holds. If ``lower`` is False then (again possibly permuted) upper
    triangular matrices are returned as outer factors.
    
    The permutation array can be used to triangularize the outer factors
    simply by a row shuffle, i.e., ``lu[perm, :]`` is an upper/lower
    triangular matrix. This is also equivalent to multiplication with a
    permutation matrix ``P.dot(lu)`` where ``P`` is a column-permuted
    identity matrix ``I[:, perm]``.
    
    Depending on the value of the boolean ``lower``, only upper or lower
    triangular part of the input array is referenced. Hence a triangular
    matrix on entry would give the same result as if the full matrix is
    supplied.
    
    Parameters
    ----------
    a : array_like
        Square input array
    lower : bool, optional
        This switches between the lower and upper triangular outer factors of
        the factorization. Lower triangular (``lower=True``) is the default.
    hermitian : bool, optional
        For complex-valued arrays, this defines whether ``a = a.conj().T`` or
        ``a = a.T`` is assumed. For real-valued arrays, this switch has no
        effect.
    overwrite_a : bool, optional
        Allow overwriting data in ``a`` (may enhance performance). The default
        is False.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    lu : ndarray
        The (possibly) permuted upper/lower triangular outer factor of the
        factorization.
    d : ndarray
        The block diagonal multiplier of the factorization.
    perm : ndarray
        The row-permutation index array that brings lu into triangular form.
    
    Raises
    ------
    ValueError
        If input array is not square.
    ComplexWarning
        If a complex-valued array with nonzero imaginary parts on the
        diagonal is given and hermitian is set to True.
    
    Examples
    --------
    Given an upper triangular array `a` that represents the full symmetric
    array with its entries, obtain `l`, 'd' and the permutation vector `perm`:
    
    >>> import numpy as np
    >>> from scipy.linalg import ldl
    >>> a = np.array([[2, -1, 3], [0, 2, 0], [0, 0, 1]])
    >>> lu, d, perm = ldl(a, lower=0) # Use the upper part
    >>> lu
    array([[ 0. ,  0. ,  1. ],
           [ 0. ,  1. , -0.5],
           [ 1. ,  1. ,  1.5]])
    >>> d
    array([[-5. ,  0. ,  0. ],
           [ 0. ,  1.5,  0. ],
           [ 0. ,  0. ,  2. ]])
    >>> perm
    array([2, 1, 0])
    >>> lu[perm, :]
    array([[ 1. ,  1. ,  1.5],
           [ 0. ,  1. , -0.5],
           [ 0. ,  0. ,  1. ]])
    >>> lu.dot(d).dot(lu.T)
    array([[ 2., -1.,  3.],
           [-1.,  2.,  0.],
           [ 3.,  0.,  1.]])
    
    Notes
    -----
    This function uses ``?SYTRF`` routines for symmetric matrices and
    ``?HETRF`` routines for Hermitian matrices from LAPACK. See [1]_ for
    the algorithm details.
    
    Depending on the ``lower`` keyword value, only lower or upper triangular
    part of the input array is referenced. Moreover, this keyword also defines
    the structure of the outer factors of the factorization.
    
    .. versionadded:: 1.1.0
    
    See also
    --------
    cholesky, lu
    
    References
    ----------
    .. [1] J.R. Bunch, L. Kaufman, Some stable methods for calculating
       inertia and solving symmetric linear systems, Math. Comput. Vol.31,
       1977. DOI: 10.2307/2005787
",function,"('(A, lower=True, hermitian=True, overwrite_a=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg._decomp_ldl.ldl,linalg._decomp_ldl,ldl,"Python Library Documentation: function ldl in module scipy.linalg._decomp_ldl

ldl(A, lower=True, hermitian=True, overwrite_a=False, check_finite=True)
    Computes the LDLt or Bunch-Kaufman factorization of a symmetric/
    hermitian matrix.
    
    This function returns a block diagonal matrix D consisting blocks of size
    at most 2x2 and also a possibly permuted unit lower triangular matrix
    ``L`` such that the factorization ``A = L D L^H`` or ``A = L D L^T``
    holds. If ``lower`` is False then (again possibly permuted) upper
    triangular matrices are returned as outer factors.
    
    The permutation array can be used to triangularize the outer factors
    simply by a row shuffle, i.e., ``lu[perm, :]`` is an upper/lower
    triangular matrix. This is also equivalent to multiplication with a
    permutation matrix ``P.dot(lu)`` where ``P`` is a column-permuted
    identity matrix ``I[:, perm]``.
    
    Depending on the value of the boolean ``lower``, only upper or lower
    triangular part of the input array is referenced. Hence a triangular
    matrix on entry would give the same result as if the full matrix is
    supplied.
    
    Parameters
    ----------
    a : array_like
        Square input array
    lower : bool, optional
        This switches between the lower and upper triangular outer factors of
        the factorization. Lower triangular (``lower=True``) is the default.
    hermitian : bool, optional
        For complex-valued arrays, this defines whether ``a = a.conj().T`` or
        ``a = a.T`` is assumed. For real-valued arrays, this switch has no
        effect.
    overwrite_a : bool, optional
        Allow overwriting data in ``a`` (may enhance performance). The default
        is False.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    lu : ndarray
        The (possibly) permuted upper/lower triangular outer factor of the
        factorization.
    d : ndarray
        The block diagonal multiplier of the factorization.
    perm : ndarray
        The row-permutation index array that brings lu into triangular form.
    
    Raises
    ------
    ValueError
        If input array is not square.
    ComplexWarning
        If a complex-valued array with nonzero imaginary parts on the
        diagonal is given and hermitian is set to True.
    
    Examples
    --------
    Given an upper triangular array `a` that represents the full symmetric
    array with its entries, obtain `l`, 'd' and the permutation vector `perm`:
    
    >>> import numpy as np
    >>> from scipy.linalg import ldl
    >>> a = np.array([[2, -1, 3], [0, 2, 0], [0, 0, 1]])
    >>> lu, d, perm = ldl(a, lower=0) # Use the upper part
    >>> lu
    array([[ 0. ,  0. ,  1. ],
           [ 0. ,  1. , -0.5],
           [ 1. ,  1. ,  1.5]])
    >>> d
    array([[-5. ,  0. ,  0. ],
           [ 0. ,  1.5,  0. ],
           [ 0. ,  0. ,  2. ]])
    >>> perm
    array([2, 1, 0])
    >>> lu[perm, :]
    array([[ 1. ,  1. ,  1.5],
           [ 0. ,  1. , -0.5],
           [ 0. ,  0. ,  1. ]])
    >>> lu.dot(d).dot(lu.T)
    array([[ 2., -1.,  3.],
           [-1.,  2.,  0.],
           [ 3.,  0.,  1.]])
    
    Notes
    -----
    This function uses ``?SYTRF`` routines for symmetric matrices and
    ``?HETRF`` routines for Hermitian matrices from LAPACK. See [1]_ for
    the algorithm details.
    
    Depending on the ``lower`` keyword value, only lower or upper triangular
    part of the input array is referenced. Moreover, this keyword also defines
    the structure of the outer factors of the factorization.
    
    .. versionadded:: 1.1.0
    
    See also
    --------
    cholesky, lu
    
    References
    ----------
    .. [1] J.R. Bunch, L. Kaufman, Some stable methods for calculating
       inertia and solving symmetric linear systems, Math. Comput. Vol.31,
       1977. DOI: 10.2307/2005787
",function,"('A', 'lower', 'hermitian', 'overwrite_a', 'check_finite')","(nan, True, True, False, True)","(nan, 'bool', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(A, lower=True, hermitian=True, overwrite_a=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg._decomp_ldl.tril,linalg._decomp_ldl,tril,"Python Library Documentation: function tril in module numpy.lib.twodim_base

tril(m, k=0)
    Lower triangle of an array.
    
    Return a copy of an array with elements above the `k`-th diagonal zeroed.
    
    Parameters
    ----------
    m : array_like, shape (M, N)
        Input array.
    k : int, optional
        Diagonal above which to zero elements.  `k = 0` (the default) is the
        main diagonal, `k < 0` is below it and `k > 0` is above.
    
    Returns
    -------
    tril : ndarray, shape (M, N)
        Lower triangle of `m`, of same shape and data-type as `m`.
    
    See Also
    --------
    triu : same thing, only for the upper triangle
    
    Examples
    --------
    >>> np.tril([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
    array([[ 0,  0,  0],
           [ 4,  0,  0],
           [ 7,  8,  0],
           [10, 11, 12]])
",function,"('(m, k=0)',)",scipy,1.1.0,scipy.linalg._decomp_ldl.tril,linalg._decomp_ldl,tril,"Python Library Documentation: function tril in module numpy.lib.twodim_base

tril(m, k=0)
    Lower triangle of an array.
    
    Return a copy of an array with elements above the `k`-th diagonal zeroed.
    
    Parameters
    ----------
    m : array_like, shape (M, N)
        Input array.
    k : int, optional
        Diagonal above which to zero elements.  `k = 0` (the default) is the
        main diagonal, `k < 0` is below it and `k > 0` is above.
    
    Returns
    -------
    tril : ndarray, shape (M, N)
        Lower triangle of `m`, of same shape and data-type as `m`.
    
    See Also
    --------
    triu : same thing, only for the upper triangle
    
    Examples
    --------
    >>> np.tril([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
    array([[ 0,  0,  0],
           [ 4,  0,  0],
           [ 7,  8,  0],
           [10, 11, 12]])
",function,"('m', 'k')","(nan, 0)","(nan, 'int')","('arg_info', 'arg_info')","('(m, k=0)',)"
scipy,1.1.0,scipy.linalg._decomp_ldl.triu,linalg._decomp_ldl,triu,"Python Library Documentation: function triu in module numpy.lib.twodim_base

triu(m, k=0)
    Upper triangle of an array.
    
    Return a copy of a matrix with the elements below the `k`-th diagonal
    zeroed.
    
    Please refer to the documentation for `tril` for further details.
    
    See Also
    --------
    tril : lower triangle of an array
    
    Examples
    --------
    >>> np.triu([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
    array([[ 1,  2,  3],
           [ 4,  5,  6],
           [ 0,  8,  9],
           [ 0,  0, 12]])
",function,"('(m, k=0)',)",scipy,1.1.0,scipy.linalg._decomp_ldl.triu,linalg._decomp_ldl,triu,"Python Library Documentation: function triu in module numpy.lib.twodim_base

triu(m, k=0)
    Upper triangle of an array.
    
    Return a copy of a matrix with the elements below the `k`-th diagonal
    zeroed.
    
    Please refer to the documentation for `tril` for further details.
    
    See Also
    --------
    tril : lower triangle of an array
    
    Examples
    --------
    >>> np.triu([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
    array([[ 1,  2,  3],
           [ 4,  5,  6],
           [ 0,  8,  9],
           [ 0,  0, 12]])
",function,"('m', 'k')","(nan, 0)","(nan, 'int')","('arg_info', 'arg_info')","('(m, k=0)',)"
scipy,1.1.0,scipy.linalg._decomp_ldl.zeros_like,linalg._decomp_ldl,zeros_like,"Python Library Documentation: function zeros_like in module numpy.core.numeric

zeros_like(a, dtype=None, order='K', subok=True)
    Return an array of zeros with the same shape and type as a given array.
    
    Parameters
    ----------
    a : array_like
        The shape and data-type of `a` define these same attributes of
        the returned array.
    dtype : data-type, optional
        Overrides the data type of the result.
    
        .. versionadded:: 1.6.0
    order : {'C', 'F', 'A', or 'K'}, optional
        Overrides the memory layout of the result. 'C' means C-order,
        'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
        'C' otherwise. 'K' means match the layout of `a` as closely
        as possible.
    
        .. versionadded:: 1.6.0
    subok : bool, optional.
        If True, then the newly created array will use the sub-class
        type of 'a', otherwise it will be a base-class array. Defaults
        to True.
    
    Returns
    -------
    out : ndarray
        Array of zeros with the same shape and type as `a`.
    
    See Also
    --------
    ones_like : Return an array of ones with shape and type of input.
    empty_like : Return an empty array with shape and type of input.
    zeros : Return a new array setting values to zero.
    ones : Return a new array setting values to one.
    empty : Return a new uninitialized array.
    
    Examples
    --------
    >>> x = np.arange(6)
    >>> x = x.reshape((2, 3))
    >>> x
    array([[0, 1, 2],
           [3, 4, 5]])
    >>> np.zeros_like(x)
    array([[0, 0, 0],
           [0, 0, 0]])
    
    >>> y = np.arange(3, dtype=float)
    >>> y
    array([ 0.,  1.,  2.])
    >>> np.zeros_like(y)
    array([ 0.,  0.,  0.])
",function,"(""(a, dtype=None, order='K', subok=True)"",)",scipy,1.1.0,scipy.linalg._decomp_ldl.zeros_like,linalg._decomp_ldl,zeros_like,"Python Library Documentation: function zeros_like in module numpy.core.numeric

zeros_like(a, dtype=None, order='K', subok=True)
    Return an array of zeros with the same shape and type as a given array.
    
    Parameters
    ----------
    a : array_like
        The shape and data-type of `a` define these same attributes of
        the returned array.
    dtype : data-type, optional
        Overrides the data type of the result.
    
        .. versionadded:: 1.6.0
    order : {'C', 'F', 'A', or 'K'}, optional
        Overrides the memory layout of the result. 'C' means C-order,
        'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
        'C' otherwise. 'K' means match the layout of `a` as closely
        as possible.
    
        .. versionadded:: 1.6.0
    subok : bool, optional.
        If True, then the newly created array will use the sub-class
        type of 'a', otherwise it will be a base-class array. Defaults
        to True.
    
    Returns
    -------
    out : ndarray
        Array of zeros with the same shape and type as `a`.
    
    See Also
    --------
    ones_like : Return an array of ones with shape and type of input.
    empty_like : Return an empty array with shape and type of input.
    zeros : Return a new array setting values to zero.
    ones : Return a new array setting values to one.
    empty : Return a new uninitialized array.
    
    Examples
    --------
    >>> x = np.arange(6)
    >>> x = x.reshape((2, 3))
    >>> x
    array([[0, 1, 2],
           [3, 4, 5]])
    >>> np.zeros_like(x)
    array([[0, 0, 0],
           [0, 0, 0]])
    
    >>> y = np.arange(3, dtype=float)
    >>> y
    array([ 0.,  1.,  2.])
    >>> np.zeros_like(y)
    array([ 0.,  0.,  0.])
",function,"('a', 'dtype', 'order', 'subok')","(nan, None, 'K', True)","(nan, 'NoneType', 'str', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a, dtype=None, order='K', subok=True)"",)"
scipy,1.1.0,scipy.linalg._decomp_polar.polar,linalg._decomp_polar,polar,"Python Library Documentation: function polar in module scipy.linalg._decomp_polar

polar(a, side='right')
    Compute the polar decomposition.
    
    Returns the factors of the polar decomposition [1]_ `u` and `p` such
    that ``a = up`` (if `side` is ""right"") or ``a = pu`` (if `side` is
    ""left""), where `p` is positive semidefinite.  Depending on the shape
    of `a`, either the rows or columns of `u` are orthonormal.  When `a`
    is a square array, `u` is a square unitary array.  When `a` is not
    square, the ""canonical polar decomposition"" [2]_ is computed.
    
    Parameters
    ----------
    a : (m, n) array_like
        The array to be factored.
    side : {'left', 'right'}, optional
        Determines whether a right or left polar decomposition is computed.
        If `side` is ""right"", then ``a = up``.  If `side` is ""left"",  then
        ``a = pu``.  The default is ""right"".
    
    Returns
    -------
    u : (m, n) ndarray
        If `a` is square, then `u` is unitary.  If m > n, then the columns
        of `a` are orthonormal, and if m < n, then the rows of `u` are
        orthonormal.
    p : ndarray
        `p` is Hermitian positive semidefinite.  If `a` is nonsingular, `p`
        is positive definite.  The shape of `p` is (n, n) or (m, m), depending
        on whether `side` is ""right"" or ""left"", respectively.
    
    References
    ----------
    .. [1] R. A. Horn and C. R. Johnson, ""Matrix Analysis"", Cambridge
           University Press, 1985.
    .. [2] N. J. Higham, ""Functions of Matrices: Theory and Computation"",
           SIAM, 2008.
    
    Examples
    --------
    >>> from scipy.linalg import polar
    >>> a = np.array([[1, -1], [2, 4]])
    >>> u, p = polar(a)
    >>> u
    array([[ 0.85749293, -0.51449576],
           [ 0.51449576,  0.85749293]])
    >>> p
    array([[ 1.88648444,  1.2004901 ],
           [ 1.2004901 ,  3.94446746]])
    
    A non-square example, with m < n:
    
    >>> b = np.array([[0.5, 1, 2], [1.5, 3, 4]])
    >>> u, p = polar(b)
    >>> u
    array([[-0.21196618, -0.42393237,  0.88054056],
           [ 0.39378971,  0.78757942,  0.4739708 ]])
    >>> p
    array([[ 0.48470147,  0.96940295,  1.15122648],
           [ 0.96940295,  1.9388059 ,  2.30245295],
           [ 1.15122648,  2.30245295,  3.65696431]])
    >>> u.dot(p)   # Verify the decomposition.
    array([[ 0.5,  1. ,  2. ],
           [ 1.5,  3. ,  4. ]])
    >>> u.dot(u.T)   # The rows of u are orthonormal.
    array([[  1.00000000e+00,  -2.07353665e-17],
           [ -2.07353665e-17,   1.00000000e+00]])
    
    Another non-square example, with m > n:
    
    >>> c = b.T
    >>> u, p = polar(c)
    >>> u
    array([[-0.21196618,  0.39378971],
           [-0.42393237,  0.78757942],
           [ 0.88054056,  0.4739708 ]])
    >>> p
    array([[ 1.23116567,  1.93241587],
           [ 1.93241587,  4.84930602]])
    >>> u.dot(p)   # Verify the decomposition.
    array([[ 0.5,  1.5],
           [ 1. ,  3. ],
           [ 2. ,  4. ]])
    >>> u.T.dot(u)  # The columns of u are orthonormal.
    array([[  1.00000000e+00,  -1.26363763e-16],
           [ -1.26363763e-16,   1.00000000e+00]])
",function,"(""(a, side='right')"",)",scipy,1.1.0,scipy.linalg._decomp_polar.polar,linalg._decomp_polar,polar,"Python Library Documentation: function polar in module scipy.linalg._decomp_polar

polar(a, side='right')
    Compute the polar decomposition.
    
    Returns the factors of the polar decomposition [1]_ `u` and `p` such
    that ``a = up`` (if `side` is ""right"") or ``a = pu`` (if `side` is
    ""left""), where `p` is positive semidefinite.  Depending on the shape
    of `a`, either the rows or columns of `u` are orthonormal.  When `a`
    is a square array, `u` is a square unitary array.  When `a` is not
    square, the ""canonical polar decomposition"" [2]_ is computed.
    
    Parameters
    ----------
    a : (m, n) array_like
        The array to be factored.
    side : {'left', 'right'}, optional
        Determines whether a right or left polar decomposition is computed.
        If `side` is ""right"", then ``a = up``.  If `side` is ""left"",  then
        ``a = pu``.  The default is ""right"".
    
    Returns
    -------
    u : (m, n) ndarray
        If `a` is square, then `u` is unitary.  If m > n, then the columns
        of `a` are orthonormal, and if m < n, then the rows of `u` are
        orthonormal.
    p : ndarray
        `p` is Hermitian positive semidefinite.  If `a` is nonsingular, `p`
        is positive definite.  The shape of `p` is (n, n) or (m, m), depending
        on whether `side` is ""right"" or ""left"", respectively.
    
    References
    ----------
    .. [1] R. A. Horn and C. R. Johnson, ""Matrix Analysis"", Cambridge
           University Press, 1985.
    .. [2] N. J. Higham, ""Functions of Matrices: Theory and Computation"",
           SIAM, 2008.
    
    Examples
    --------
    >>> from scipy.linalg import polar
    >>> a = np.array([[1, -1], [2, 4]])
    >>> u, p = polar(a)
    >>> u
    array([[ 0.85749293, -0.51449576],
           [ 0.51449576,  0.85749293]])
    >>> p
    array([[ 1.88648444,  1.2004901 ],
           [ 1.2004901 ,  3.94446746]])
    
    A non-square example, with m < n:
    
    >>> b = np.array([[0.5, 1, 2], [1.5, 3, 4]])
    >>> u, p = polar(b)
    >>> u
    array([[-0.21196618, -0.42393237,  0.88054056],
           [ 0.39378971,  0.78757942,  0.4739708 ]])
    >>> p
    array([[ 0.48470147,  0.96940295,  1.15122648],
           [ 0.96940295,  1.9388059 ,  2.30245295],
           [ 1.15122648,  2.30245295,  3.65696431]])
    >>> u.dot(p)   # Verify the decomposition.
    array([[ 0.5,  1. ,  2. ],
           [ 1.5,  3. ,  4. ]])
    >>> u.dot(u.T)   # The rows of u are orthonormal.
    array([[  1.00000000e+00,  -2.07353665e-17],
           [ -2.07353665e-17,   1.00000000e+00]])
    
    Another non-square example, with m > n:
    
    >>> c = b.T
    >>> u, p = polar(c)
    >>> u
    array([[-0.21196618,  0.39378971],
           [-0.42393237,  0.78757942],
           [ 0.88054056,  0.4739708 ]])
    >>> p
    array([[ 1.23116567,  1.93241587],
           [ 1.93241587,  4.84930602]])
    >>> u.dot(p)   # Verify the decomposition.
    array([[ 0.5,  1.5],
           [ 1. ,  3. ],
           [ 2. ,  4. ]])
    >>> u.T.dot(u)  # The columns of u are orthonormal.
    array([[  1.00000000e+00,  -1.26363763e-16],
           [ -1.26363763e-16,   1.00000000e+00]])
",function,"('a', 'side')","(nan, 'right')","(nan, 'str')","('arg_info', 'arg_info')","(""(a, side='right')"",)"
scipy,1.1.0,scipy.linalg._decomp_polar.svd,linalg._decomp_polar,svd,"Python Library Documentation: function svd in module scipy.linalg.decomp_svd

svd(a, full_matrices=True, compute_uv=True, overwrite_a=False, check_finite=True, lapack_driver='gesdd')
    Singular Value Decomposition.
    
    Factorizes the matrix `a` into two unitary matrices ``U`` and ``Vh``, and
    a 1-D array ``s`` of singular values (real, non-negative) such that
    ``a == U @ S @ Vh``, where ``S`` is a suitably shaped matrix of zeros with
    main diagonal ``s``.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to decompose.
    full_matrices : bool, optional
        If True (default), `U` and `Vh` are of shape ``(M, M)``, ``(N, N)``.
        If False, the shapes are ``(M, K)`` and ``(K, N)``, where
        ``K = min(M, N)``.
    compute_uv : bool, optional
        Whether to compute also ``U`` and ``Vh`` in addition to ``s``.
        Default is True.
    overwrite_a : bool, optional
        Whether to overwrite `a`; may improve performance.
        Default is False.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    lapack_driver : {'gesdd', 'gesvd'}, optional
        Whether to use the more efficient divide-and-conquer approach
        (``'gesdd'``) or general rectangular approach (``'gesvd'``)
        to compute the SVD. MATLAB and Octave use the ``'gesvd'`` approach.
        Default is ``'gesdd'``.
    
        .. versionadded:: 0.18
    
    Returns
    -------
    U : ndarray
        Unitary matrix having left singular vectors as columns.
        Of shape ``(M, M)`` or ``(M, K)``, depending on `full_matrices`.
    s : ndarray
        The singular values, sorted in non-increasing order.
        Of shape (K,), with ``K = min(M, N)``.
    Vh : ndarray
        Unitary matrix having right singular vectors as rows.
        Of shape ``(N, N)`` or ``(K, N)`` depending on `full_matrices`.
    
    For ``compute_uv=False``, only ``s`` is returned.
    
    Raises
    ------
    LinAlgError
        If SVD computation does not converge.
    
    See also
    --------
    svdvals : Compute singular values of a matrix.
    diagsvd : Construct the Sigma matrix, given the vector s.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> m, n = 9, 6
    >>> a = np.random.randn(m, n) + 1.j*np.random.randn(m, n)
    >>> U, s, Vh = linalg.svd(a)
    >>> U.shape,  s.shape, Vh.shape
    ((9, 9), (6,), (6, 6))
    
    Reconstruct the original matrix from the decomposition:
    
    >>> sigma = np.zeros((m, n))
    >>> for i in range(min(m, n)):
    ...     sigma[i, i] = s[i]
    >>> a1 = np.dot(U, np.dot(sigma, Vh))
    >>> np.allclose(a, a1)
    True
    
    Alternatively, use ``full_matrices=False`` (notice that the shape of
    ``U`` is then ``(m, n)`` instead of ``(m, m)``):
    
    >>> U, s, Vh = linalg.svd(a, full_matrices=False)
    >>> U.shape, s.shape, Vh.shape
    ((9, 6), (6,), (6, 6))
    >>> S = np.diag(s)
    >>> np.allclose(a, np.dot(U, np.dot(S, Vh)))
    True
    
    >>> s2 = linalg.svd(a, compute_uv=False)
    >>> np.allclose(s, s2)
    True
",function,"(""(a, full_matrices=True, compute_uv=True, overwrite_a=False, check_finite=True, lapack_driver='gesdd')"",)",scipy,1.1.0,scipy.linalg._decomp_polar.svd,linalg._decomp_polar,svd,"Python Library Documentation: function svd in module scipy.linalg.decomp_svd

svd(a, full_matrices=True, compute_uv=True, overwrite_a=False, check_finite=True, lapack_driver='gesdd')
    Singular Value Decomposition.
    
    Factorizes the matrix `a` into two unitary matrices ``U`` and ``Vh``, and
    a 1-D array ``s`` of singular values (real, non-negative) such that
    ``a == U @ S @ Vh``, where ``S`` is a suitably shaped matrix of zeros with
    main diagonal ``s``.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to decompose.
    full_matrices : bool, optional
        If True (default), `U` and `Vh` are of shape ``(M, M)``, ``(N, N)``.
        If False, the shapes are ``(M, K)`` and ``(K, N)``, where
        ``K = min(M, N)``.
    compute_uv : bool, optional
        Whether to compute also ``U`` and ``Vh`` in addition to ``s``.
        Default is True.
    overwrite_a : bool, optional
        Whether to overwrite `a`; may improve performance.
        Default is False.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    lapack_driver : {'gesdd', 'gesvd'}, optional
        Whether to use the more efficient divide-and-conquer approach
        (``'gesdd'``) or general rectangular approach (``'gesvd'``)
        to compute the SVD. MATLAB and Octave use the ``'gesvd'`` approach.
        Default is ``'gesdd'``.
    
        .. versionadded:: 0.18
    
    Returns
    -------
    U : ndarray
        Unitary matrix having left singular vectors as columns.
        Of shape ``(M, M)`` or ``(M, K)``, depending on `full_matrices`.
    s : ndarray
        The singular values, sorted in non-increasing order.
        Of shape (K,), with ``K = min(M, N)``.
    Vh : ndarray
        Unitary matrix having right singular vectors as rows.
        Of shape ``(N, N)`` or ``(K, N)`` depending on `full_matrices`.
    
    For ``compute_uv=False``, only ``s`` is returned.
    
    Raises
    ------
    LinAlgError
        If SVD computation does not converge.
    
    See also
    --------
    svdvals : Compute singular values of a matrix.
    diagsvd : Construct the Sigma matrix, given the vector s.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> m, n = 9, 6
    >>> a = np.random.randn(m, n) + 1.j*np.random.randn(m, n)
    >>> U, s, Vh = linalg.svd(a)
    >>> U.shape,  s.shape, Vh.shape
    ((9, 9), (6,), (6, 6))
    
    Reconstruct the original matrix from the decomposition:
    
    >>> sigma = np.zeros((m, n))
    >>> for i in range(min(m, n)):
    ...     sigma[i, i] = s[i]
    >>> a1 = np.dot(U, np.dot(sigma, Vh))
    >>> np.allclose(a, a1)
    True
    
    Alternatively, use ``full_matrices=False`` (notice that the shape of
    ``U`` is then ``(m, n)`` instead of ``(m, m)``):
    
    >>> U, s, Vh = linalg.svd(a, full_matrices=False)
    >>> U.shape, s.shape, Vh.shape
    ((9, 6), (6,), (6, 6))
    >>> S = np.diag(s)
    >>> np.allclose(a, np.dot(U, np.dot(S, Vh)))
    True
    
    >>> s2 = linalg.svd(a, compute_uv=False)
    >>> np.allclose(s, s2)
    True
",function,"('a', 'full_matrices', 'compute_uv', 'overwrite_a', 'check_finite', 'lapack_driver')","(nan, True, True, False, True, 'gesdd')","(nan, 'bool', 'bool', 'bool', 'bool', 'str')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a, full_matrices=True, compute_uv=True, overwrite_a=False, check_finite=True, lapack_driver='gesdd')"",)"
scipy,1.1.0,scipy.linalg._decomp_qz.LinAlgError,linalg._decomp_qz,LinAlgError,"Python Library Documentation: class LinAlgError in module numpy.linalg.linalg

class LinAlgError(builtins.Exception)
 |  Generic Python-exception-derived object raised by linalg functions.
 |  
 |  General purpose exception class, derived from Python's exception.Exception
 |  class, programmatically raised in linalg functions when a Linear
 |  Algebra-related condition would prevent further correct execution of the
 |  function.
 |  
 |  Parameters
 |  ----------
 |  None
 |  
 |  Examples
 |  --------
 |  >>> from numpy import linalg as LA
 |  >>> LA.inv(np.zeros((2,2)))
 |  Traceback (most recent call last):
 |    File ""<stdin>"", line 1, in <module>
 |    File ""...linalg.py"", line 350,
 |      in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
 |    File ""...linalg.py"", line 249,
 |      in solve
 |      raise LinAlgError('Singular matrix')
 |  numpy.linalg.LinAlgError: Singular matrix
 |  
 |  Method resolution order:
 |      LinAlgError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg._decomp_qz.LinAlgError,linalg._decomp_qz,LinAlgError,"Python Library Documentation: class LinAlgError in module numpy.linalg.linalg

class LinAlgError(builtins.Exception)
 |  Generic Python-exception-derived object raised by linalg functions.
 |  
 |  General purpose exception class, derived from Python's exception.Exception
 |  class, programmatically raised in linalg functions when a Linear
 |  Algebra-related condition would prevent further correct execution of the
 |  function.
 |  
 |  Parameters
 |  ----------
 |  None
 |  
 |  Examples
 |  --------
 |  >>> from numpy import linalg as LA
 |  >>> LA.inv(np.zeros((2,2)))
 |  Traceback (most recent call last):
 |    File ""<stdin>"", line 1, in <module>
 |    File ""...linalg.py"", line 350,
 |      in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
 |    File ""...linalg.py"", line 249,
 |      in solve
 |      raise LinAlgError('Singular matrix')
 |  numpy.linalg.LinAlgError: Singular matrix
 |  
 |  Method resolution order:
 |      LinAlgError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg._decomp_qz.LinAlgWarning,linalg._decomp_qz,LinAlgWarning,"Python Library Documentation: class LinAlgWarning in module scipy.linalg.misc

class LinAlgWarning(builtins.RuntimeWarning)
 |  The warning emitted when a linear algebra related operation is close
 |  to fail conditions of the algorithm or loss of accuracy is expected.
 |  
 |  Method resolution order:
 |      LinAlgWarning
 |      builtins.RuntimeWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.RuntimeWarning:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg._decomp_qz.LinAlgWarning,linalg._decomp_qz,LinAlgWarning,"Python Library Documentation: class LinAlgWarning in module scipy.linalg.misc

class LinAlgWarning(builtins.RuntimeWarning)
 |  The warning emitted when a linear algebra related operation is close
 |  to fail conditions of the algorithm or loss of accuracy is expected.
 |  
 |  Method resolution order:
 |      LinAlgWarning
 |      builtins.RuntimeWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.RuntimeWarning:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg._decomp_qz._datacopied,linalg._decomp_qz,_datacopied,"Python Library Documentation: function _datacopied in module scipy.linalg.misc

_datacopied(arr, original)
    Strict check for `arr` not sharing any data with `original`,
    under the assumption that arr = asarray(original)
",function,"('(arr, original)',)",scipy,1.1.0,scipy.linalg._decomp_qz._datacopied,linalg._decomp_qz,_datacopied,"Python Library Documentation: function _datacopied in module scipy.linalg.misc

_datacopied(arr, original)
    Strict check for `arr` not sharing any data with `original`,
    under the assumption that arr = asarray(original)
",function,"('arr', 'original')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(arr, original)',)"
scipy,1.1.0,scipy.linalg._decomp_qz._iuc,linalg._decomp_qz,_iuc,"Python Library Documentation: function _iuc in module scipy.linalg._decomp_qz

_iuc(x, y)
",function,"('(x, y)',)",scipy,1.1.0,scipy.linalg._decomp_qz._iuc,linalg._decomp_qz,_iuc,"Python Library Documentation: function _iuc in module scipy.linalg._decomp_qz

_iuc(x, y)
",function,"('x', 'y')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(x, y)',)"
scipy,1.1.0,scipy.linalg._decomp_qz._lhp,linalg._decomp_qz,_lhp,"Python Library Documentation: function _lhp in module scipy.linalg._decomp_qz

_lhp(x, y)
",function,"('(x, y)',)",scipy,1.1.0,scipy.linalg._decomp_qz._lhp,linalg._decomp_qz,_lhp,"Python Library Documentation: function _lhp in module scipy.linalg._decomp_qz

_lhp(x, y)
",function,"('x', 'y')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(x, y)',)"
scipy,1.1.0,scipy.linalg._decomp_qz._ouc,linalg._decomp_qz,_ouc,"Python Library Documentation: function _ouc in module scipy.linalg._decomp_qz

_ouc(x, y)
",function,"('(x, y)',)",scipy,1.1.0,scipy.linalg._decomp_qz._ouc,linalg._decomp_qz,_ouc,"Python Library Documentation: function _ouc in module scipy.linalg._decomp_qz

_ouc(x, y)
",function,"('x', 'y')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(x, y)',)"
scipy,1.1.0,scipy.linalg._decomp_qz._qz,linalg._decomp_qz,_qz,"Python Library Documentation: function _qz in module scipy.linalg._decomp_qz

_qz(A, B, output='real', lwork=None, sort=None, overwrite_a=False, overwrite_b=False, check_finite=True)
",function,"(""(A, B, output='real', lwork=None, sort=None, overwrite_a=False, overwrite_b=False, check_finite=True)"",)",scipy,1.1.0,scipy.linalg._decomp_qz._qz,linalg._decomp_qz,_qz,"Python Library Documentation: function _qz in module scipy.linalg._decomp_qz

_qz(A, B, output='real', lwork=None, sort=None, overwrite_a=False, overwrite_b=False, check_finite=True)
",function,"('A', 'B', 'output', 'lwork', 'sort', 'overwrite_a', 'overwrite_b', 'check_finite')","(nan, nan, 'real', None, None, False, False, True)","(nan, nan, 'str', 'NoneType', 'NoneType', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(A, B, output='real', lwork=None, sort=None, overwrite_a=False, overwrite_b=False, check_finite=True)"",)"
scipy,1.1.0,scipy.linalg._decomp_qz._rhp,linalg._decomp_qz,_rhp,"Python Library Documentation: function _rhp in module scipy.linalg._decomp_qz

_rhp(x, y)
",function,"('(x, y)',)",scipy,1.1.0,scipy.linalg._decomp_qz._rhp,linalg._decomp_qz,_rhp,"Python Library Documentation: function _rhp in module scipy.linalg._decomp_qz

_rhp(x, y)
",function,"('x', 'y')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(x, y)',)"
scipy,1.1.0,scipy.linalg._decomp_qz._select_function,linalg._decomp_qz,_select_function,"Python Library Documentation: function _select_function in module scipy.linalg._decomp_qz

_select_function(sort)
",function,"('(sort)',)",scipy,1.1.0,scipy.linalg._decomp_qz._select_function,linalg._decomp_qz,_select_function,"Python Library Documentation: function _select_function in module scipy.linalg._decomp_qz

_select_function(sort)
",function,"('sort',)","(nan,)","(nan,)","('arg_info',)","('(sort)',)"
scipy,1.1.0,scipy.linalg._decomp_qz.asarray_chkfinite,linalg._decomp_qz,asarray_chkfinite,"Python Library Documentation: function asarray_chkfinite in module numpy.lib.function_base

asarray_chkfinite(a, dtype=None, order=None)
    Convert the input to an array, checking for NaNs or Infs.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.  Success requires no NaNs or Infs.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
         Whether to use row-major (C-style) or
         column-major (Fortran-style) memory representation.
         Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray.  If `a` is a subclass of ndarray, a base
        class ndarray is returned.
    
    Raises
    ------
    ValueError
        Raises ValueError if `a` contains NaN (Not a Number) or Inf (Infinity).
    
    See Also
    --------
    asarray : Create and array.
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array.  If all elements are finite
    ``asarray_chkfinite`` is identical to ``asarray``.
    
    >>> a = [1, 2]
    >>> np.asarray_chkfinite(a, dtype=float)
    array([1., 2.])
    
    Raises ValueError if array_like contains Nans or Infs.
    
    >>> a = [1, 2, np.inf]
    >>> try:
    ...     np.asarray_chkfinite(a)
    ... except ValueError:
    ...     print('ValueError')
    ...
    ValueError
",function,"('(a, dtype=None, order=None)',)",scipy,1.1.0,scipy.linalg._decomp_qz.asarray_chkfinite,linalg._decomp_qz,asarray_chkfinite,"Python Library Documentation: function asarray_chkfinite in module numpy.lib.function_base

asarray_chkfinite(a, dtype=None, order=None)
    Convert the input to an array, checking for NaNs or Infs.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.  Success requires no NaNs or Infs.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
         Whether to use row-major (C-style) or
         column-major (Fortran-style) memory representation.
         Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray.  If `a` is a subclass of ndarray, a base
        class ndarray is returned.
    
    Raises
    ------
    ValueError
        Raises ValueError if `a` contains NaN (Not a Number) or Inf (Infinity).
    
    See Also
    --------
    asarray : Create and array.
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array.  If all elements are finite
    ``asarray_chkfinite`` is identical to ``asarray``.
    
    >>> a = [1, 2]
    >>> np.asarray_chkfinite(a, dtype=float)
    array([1., 2.])
    
    Raises ValueError if array_like contains Nans or Infs.
    
    >>> a = [1, 2, np.inf]
    >>> try:
    ...     np.asarray_chkfinite(a)
    ... except ValueError:
    ...     print('ValueError')
    ...
    ValueError
",function,"('a', 'dtype', 'order')","(nan, None, None)","(nan, 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(a, dtype=None, order=None)',)"
scipy,1.1.0,scipy.linalg._decomp_qz.callable,linalg._decomp_qz,callable,"Python Library Documentation: function callable in module scipy._lib.six

callable(obj)
",function,"('(obj)',)",scipy,1.1.0,scipy.linalg._decomp_qz.callable,linalg._decomp_qz,callable,"Python Library Documentation: function callable in module scipy._lib.six

callable(obj)
",function,"('obj',)","(nan,)","(nan,)","('arg_info',)","('(obj)',)"
scipy,1.1.0,scipy.linalg._decomp_qz.get_lapack_funcs,linalg._decomp_qz,get_lapack_funcs,"Python Library Documentation: function get_lapack_funcs in module scipy.linalg.lapack

get_lapack_funcs(names, arrays=(), dtype=None)
    Return available LAPACK function objects from names.
    
    Arrays are used to determine the optimal prefix of LAPACK routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of LAPACK functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of LAPACK
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In LAPACK, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively, and
    are stored in attribute ``typecode`` of the returned functions.
    
    Examples
    --------
    Suppose we would like to use '?lange' routine which computes the selected
    norm of an array. We pass our array in order to get the correct 'lange'
    flavor.
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_lange = LA.get_lapack_funcs('lange', (a,))
    >>> x_lange.typecode
    'd'
    >>> x_lange = LA.get_lapack_funcs('lange',(a*1j,))
    >>> x_lange.typecode
    'z'
    
    Several LAPACK routines work best when its internal WORK array has
    the optimal size (big enough for fast computation and small enough to
    avoid waste of memory). This size is determined also by a dedicated query
    to the function which is often wrapped as a standalone function and
    commonly denoted as ``###_lwork``. Below is an example for ``?sysv``
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(1000,1000)
    >>> b = np.random.rand(1000,1)*1j
    >>> # We pick up zsysv and zsysv_lwork due to b array
    ... xsysv, xlwork = LA.get_lapack_funcs(('sysv', 'sysv_lwork'), (a, b))
    >>> opt_lwork, _ = xlwork(a.shape[0])  # returns a complex for 'z' prefix
    >>> udut, ipiv, x, info = xsysv(a, b, lwork=int(opt_lwork.real))
",function,"('(names, arrays=(), dtype=None)',)",scipy,1.1.0,scipy.linalg._decomp_qz.get_lapack_funcs,linalg._decomp_qz,get_lapack_funcs,"Python Library Documentation: function get_lapack_funcs in module scipy.linalg.lapack

get_lapack_funcs(names, arrays=(), dtype=None)
    Return available LAPACK function objects from names.
    
    Arrays are used to determine the optimal prefix of LAPACK routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of LAPACK functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of LAPACK
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In LAPACK, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively, and
    are stored in attribute ``typecode`` of the returned functions.
    
    Examples
    --------
    Suppose we would like to use '?lange' routine which computes the selected
    norm of an array. We pass our array in order to get the correct 'lange'
    flavor.
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_lange = LA.get_lapack_funcs('lange', (a,))
    >>> x_lange.typecode
    'd'
    >>> x_lange = LA.get_lapack_funcs('lange',(a*1j,))
    >>> x_lange.typecode
    'z'
    
    Several LAPACK routines work best when its internal WORK array has
    the optimal size (big enough for fast computation and small enough to
    avoid waste of memory). This size is determined also by a dedicated query
    to the function which is often wrapped as a standalone function and
    commonly denoted as ``###_lwork``. Below is an example for ``?sysv``
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(1000,1000)
    >>> b = np.random.rand(1000,1)*1j
    >>> # We pick up zsysv and zsysv_lwork due to b array
    ... xsysv, xlwork = LA.get_lapack_funcs(('sysv', 'sysv_lwork'), (a, b))
    >>> opt_lwork, _ = xlwork(a.shape[0])  # returns a complex for 'z' prefix
    >>> udut, ipiv, x, info = xsysv(a, b, lwork=int(opt_lwork.real))
",function,"('names', 'arrays', 'dtype')","(nan, (), None)","(nan, 'tuple', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(names, arrays=(), dtype=None)',)"
scipy,1.1.0,scipy.linalg._decomp_qz.ordqz,linalg._decomp_qz,ordqz,"Python Library Documentation: function ordqz in module scipy.linalg._decomp_qz

ordqz(A, B, sort='lhp', output='real', overwrite_a=False, overwrite_b=False, check_finite=True)
    QZ decomposition for a pair of matrices with reordering.
    
    .. versionadded:: 0.17.0
    
    Parameters
    ----------
    A : (N, N) array_like
        2d array to decompose
    B : (N, N) array_like
        2d array to decompose
    sort : {callable, 'lhp', 'rhp', 'iuc', 'ouc'}, optional
        Specifies whether the upper eigenvalues should be sorted. A
        callable may be passed that, given an ordered pair ``(alpha,
        beta)`` representing the eigenvalue ``x = (alpha/beta)``,
        returns a boolean denoting whether the eigenvalue should be
        sorted to the top-left (True). For the real matrix pairs
        ``beta`` is real while ``alpha`` can be complex, and for
        complex matrix pairs both ``alpha`` and ``beta`` can be
        complex. The callable must be able to accept a numpy
        array. Alternatively, string parameters may be used:
    
            - 'lhp'   Left-hand plane (x.real < 0.0)
            - 'rhp'   Right-hand plane (x.real > 0.0)
            - 'iuc'   Inside the unit circle (x*x.conjugate() < 1.0)
            - 'ouc'   Outside the unit circle (x*x.conjugate() > 1.0)
    
        With the predefined sorting functions, an infinite eigenvalue
        (i.e. ``alpha != 0`` and ``beta = 0``) is considered to lie in
        neither the left-hand nor the right-hand plane, but it is
        considered to lie outside the unit circle. For the eigenvalue
        ``(alpha, beta) = (0, 0)`` the predefined sorting functions
        all return `False`.
    output : str {'real','complex'}, optional
        Construct the real or complex QZ decomposition for real matrices.
        Default is 'real'.
    overwrite_a : bool, optional
        If True, the contents of A are overwritten.
    overwrite_b : bool, optional
        If True, the contents of B are overwritten.
    check_finite : bool, optional
        If true checks the elements of `A` and `B` are finite numbers. If
        false does no checking and passes matrix through to
        underlying algorithm.
    
    Returns
    -------
    AA : (N, N) ndarray
        Generalized Schur form of A.
    BB : (N, N) ndarray
        Generalized Schur form of B.
    alpha : (N,) ndarray
        alpha = alphar + alphai * 1j. See notes.
    beta : (N,) ndarray
        See notes.
    Q : (N, N) ndarray
        The left Schur vectors.
    Z : (N, N) ndarray
        The right Schur vectors.
    
    Notes
    -----
    On exit, ``(ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N``, will be the
    generalized eigenvalues.  ``ALPHAR(j) + ALPHAI(j)*i`` and
    ``BETA(j),j=1,...,N`` are the diagonals of the complex Schur form (S,T)
    that would result if the 2-by-2 diagonal blocks of the real generalized
    Schur form of (A,B) were further reduced to triangular form using complex
    unitary transformations. If ALPHAI(j) is zero, then the j-th eigenvalue is
    real; if positive, then the ``j``-th and ``(j+1)``-st eigenvalues are a
    complex conjugate pair, with ``ALPHAI(j+1)`` negative.
    
    See also
    --------
    qz
    
    Examples
    --------
    >>> from scipy.linalg import ordqz
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> B = np.array([[0, 6, 0, 0], [5, 0, 2, 1], [5, 2, 6, 6], [4, 7, 7, 7]])
    >>> AA, BB, alpha, beta, Q, Z = ordqz(A, B, sort='lhp')
    
    Since we have sorted for left half plane eigenvalues, negatives come first
    
    >>> (alpha/beta).real < 0
    array([ True,  True, False, False], dtype=bool)
",function,"(""(A, B, sort='lhp', output='real', overwrite_a=False, overwrite_b=False, check_finite=True)"",)",scipy,1.1.0,scipy.linalg._decomp_qz.ordqz,linalg._decomp_qz,ordqz,"Python Library Documentation: function ordqz in module scipy.linalg._decomp_qz

ordqz(A, B, sort='lhp', output='real', overwrite_a=False, overwrite_b=False, check_finite=True)
    QZ decomposition for a pair of matrices with reordering.
    
    .. versionadded:: 0.17.0
    
    Parameters
    ----------
    A : (N, N) array_like
        2d array to decompose
    B : (N, N) array_like
        2d array to decompose
    sort : {callable, 'lhp', 'rhp', 'iuc', 'ouc'}, optional
        Specifies whether the upper eigenvalues should be sorted. A
        callable may be passed that, given an ordered pair ``(alpha,
        beta)`` representing the eigenvalue ``x = (alpha/beta)``,
        returns a boolean denoting whether the eigenvalue should be
        sorted to the top-left (True). For the real matrix pairs
        ``beta`` is real while ``alpha`` can be complex, and for
        complex matrix pairs both ``alpha`` and ``beta`` can be
        complex. The callable must be able to accept a numpy
        array. Alternatively, string parameters may be used:
    
            - 'lhp'   Left-hand plane (x.real < 0.0)
            - 'rhp'   Right-hand plane (x.real > 0.0)
            - 'iuc'   Inside the unit circle (x*x.conjugate() < 1.0)
            - 'ouc'   Outside the unit circle (x*x.conjugate() > 1.0)
    
        With the predefined sorting functions, an infinite eigenvalue
        (i.e. ``alpha != 0`` and ``beta = 0``) is considered to lie in
        neither the left-hand nor the right-hand plane, but it is
        considered to lie outside the unit circle. For the eigenvalue
        ``(alpha, beta) = (0, 0)`` the predefined sorting functions
        all return `False`.
    output : str {'real','complex'}, optional
        Construct the real or complex QZ decomposition for real matrices.
        Default is 'real'.
    overwrite_a : bool, optional
        If True, the contents of A are overwritten.
    overwrite_b : bool, optional
        If True, the contents of B are overwritten.
    check_finite : bool, optional
        If true checks the elements of `A` and `B` are finite numbers. If
        false does no checking and passes matrix through to
        underlying algorithm.
    
    Returns
    -------
    AA : (N, N) ndarray
        Generalized Schur form of A.
    BB : (N, N) ndarray
        Generalized Schur form of B.
    alpha : (N,) ndarray
        alpha = alphar + alphai * 1j. See notes.
    beta : (N,) ndarray
        See notes.
    Q : (N, N) ndarray
        The left Schur vectors.
    Z : (N, N) ndarray
        The right Schur vectors.
    
    Notes
    -----
    On exit, ``(ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N``, will be the
    generalized eigenvalues.  ``ALPHAR(j) + ALPHAI(j)*i`` and
    ``BETA(j),j=1,...,N`` are the diagonals of the complex Schur form (S,T)
    that would result if the 2-by-2 diagonal blocks of the real generalized
    Schur form of (A,B) were further reduced to triangular form using complex
    unitary transformations. If ALPHAI(j) is zero, then the j-th eigenvalue is
    real; if positive, then the ``j``-th and ``(j+1)``-st eigenvalues are a
    complex conjugate pair, with ``ALPHAI(j+1)`` negative.
    
    See also
    --------
    qz
    
    Examples
    --------
    >>> from scipy.linalg import ordqz
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> B = np.array([[0, 6, 0, 0], [5, 0, 2, 1], [5, 2, 6, 6], [4, 7, 7, 7]])
    >>> AA, BB, alpha, beta, Q, Z = ordqz(A, B, sort='lhp')
    
    Since we have sorted for left half plane eigenvalues, negatives come first
    
    >>> (alpha/beta).real < 0
    array([ True,  True, False, False], dtype=bool)
",function,"('A', 'B', 'sort', 'output', 'overwrite_a', 'overwrite_b', 'check_finite')","(nan, nan, 'lhp', 'real', False, False, True)","(nan, nan, 'str', 'str', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(A, B, sort='lhp', output='real', overwrite_a=False, overwrite_b=False, check_finite=True)"",)"
scipy,1.1.0,scipy.linalg._decomp_qz.qz,linalg._decomp_qz,qz,"Python Library Documentation: function qz in module scipy.linalg._decomp_qz

qz(A, B, output='real', lwork=None, sort=None, overwrite_a=False, overwrite_b=False, check_finite=True)
    QZ decomposition for generalized eigenvalues of a pair of matrices.
    
    The QZ, or generalized Schur, decomposition for a pair of N x N
    nonsymmetric matrices (A,B) is::
    
        (A,B) = (Q*AA*Z', Q*BB*Z')
    
    where AA, BB is in generalized Schur form if BB is upper-triangular
    with non-negative diagonal and AA is upper-triangular, or for real QZ
    decomposition (``output='real'``) block upper triangular with 1x1
    and 2x2 blocks.  In this case, the 1x1 blocks correspond to real
    generalized eigenvalues and 2x2 blocks are 'standardized' by making
    the corresponding elements of BB have the form::
    
        [ a 0 ]
        [ 0 b ]
    
    and the pair of corresponding 2x2 blocks in AA and BB will have a complex
    conjugate pair of generalized eigenvalues.  If (``output='complex'``) or
    A and B are complex matrices, Z' denotes the conjugate-transpose of Z.
    Q and Z are unitary matrices.
    
    Parameters
    ----------
    A : (N, N) array_like
        2d array to decompose
    B : (N, N) array_like
        2d array to decompose
    output : {'real', 'complex'}, optional
        Construct the real or complex QZ decomposition for real matrices.
        Default is 'real'.
    lwork : int, optional
        Work array size.  If None or -1, it is automatically computed.
    sort : {None, callable, 'lhp', 'rhp', 'iuc', 'ouc'}, optional
        NOTE: THIS INPUT IS DISABLED FOR NOW. Use ordqz instead.
    
        Specifies whether the upper eigenvalues should be sorted.  A callable
        may be passed that, given a eigenvalue, returns a boolean denoting
        whether the eigenvalue should be sorted to the top-left (True). For
        real matrix pairs, the sort function takes three real arguments
        (alphar, alphai, beta). The eigenvalue
        ``x = (alphar + alphai*1j)/beta``.  For complex matrix pairs or
        output='complex', the sort function takes two complex arguments
        (alpha, beta). The eigenvalue ``x = (alpha/beta)``.  Alternatively,
        string parameters may be used:
    
            - 'lhp'   Left-hand plane (x.real < 0.0)
            - 'rhp'   Right-hand plane (x.real > 0.0)
            - 'iuc'   Inside the unit circle (x*x.conjugate() < 1.0)
            - 'ouc'   Outside the unit circle (x*x.conjugate() > 1.0)
    
        Defaults to None (no sorting).
    overwrite_a : bool, optional
        Whether to overwrite data in a (may improve performance)
    overwrite_b : bool, optional
        Whether to overwrite data in b (may improve performance)
    check_finite : bool, optional
        If true checks the elements of `A` and `B` are finite numbers. If
        false does no checking and passes matrix through to
        underlying algorithm.
    
    Returns
    -------
    AA : (N, N) ndarray
        Generalized Schur form of A.
    BB : (N, N) ndarray
        Generalized Schur form of B.
    Q : (N, N) ndarray
        The left Schur vectors.
    Z : (N, N) ndarray
        The right Schur vectors.
    
    Notes
    -----
    Q is transposed versus the equivalent function in Matlab.
    
    .. versionadded:: 0.11.0
    
    Examples
    --------
    >>> from scipy import linalg
    >>> np.random.seed(1234)
    >>> A = np.arange(9).reshape((3, 3))
    >>> B = np.random.randn(3, 3)
    
    >>> AA, BB, Q, Z = linalg.qz(A, B)
    >>> AA
    array([[-13.40928183,  -4.62471562,   1.09215523],
           [  0.        ,   0.        ,   1.22805978],
           [  0.        ,   0.        ,   0.31973817]])
    >>> BB
    array([[ 0.33362547, -1.37393632,  0.02179805],
           [ 0.        ,  1.68144922,  0.74683866],
           [ 0.        ,  0.        ,  0.9258294 ]])
    >>> Q
    array([[ 0.14134727, -0.97562773,  0.16784365],
           [ 0.49835904, -0.07636948, -0.86360059],
           [ 0.85537081,  0.20571399,  0.47541828]])
    >>> Z
    array([[-0.24900855, -0.51772687,  0.81850696],
           [-0.79813178,  0.58842606,  0.12938478],
           [-0.54861681, -0.6210585 , -0.55973739]])
    
    See also
    --------
    ordqz
",function,"(""(A, B, output='real', lwork=None, sort=None, overwrite_a=False, overwrite_b=False, check_finite=True)"",)",scipy,1.1.0,scipy.linalg._decomp_qz.qz,linalg._decomp_qz,qz,"Python Library Documentation: function qz in module scipy.linalg._decomp_qz

qz(A, B, output='real', lwork=None, sort=None, overwrite_a=False, overwrite_b=False, check_finite=True)
    QZ decomposition for generalized eigenvalues of a pair of matrices.
    
    The QZ, or generalized Schur, decomposition for a pair of N x N
    nonsymmetric matrices (A,B) is::
    
        (A,B) = (Q*AA*Z', Q*BB*Z')
    
    where AA, BB is in generalized Schur form if BB is upper-triangular
    with non-negative diagonal and AA is upper-triangular, or for real QZ
    decomposition (``output='real'``) block upper triangular with 1x1
    and 2x2 blocks.  In this case, the 1x1 blocks correspond to real
    generalized eigenvalues and 2x2 blocks are 'standardized' by making
    the corresponding elements of BB have the form::
    
        [ a 0 ]
        [ 0 b ]
    
    and the pair of corresponding 2x2 blocks in AA and BB will have a complex
    conjugate pair of generalized eigenvalues.  If (``output='complex'``) or
    A and B are complex matrices, Z' denotes the conjugate-transpose of Z.
    Q and Z are unitary matrices.
    
    Parameters
    ----------
    A : (N, N) array_like
        2d array to decompose
    B : (N, N) array_like
        2d array to decompose
    output : {'real', 'complex'}, optional
        Construct the real or complex QZ decomposition for real matrices.
        Default is 'real'.
    lwork : int, optional
        Work array size.  If None or -1, it is automatically computed.
    sort : {None, callable, 'lhp', 'rhp', 'iuc', 'ouc'}, optional
        NOTE: THIS INPUT IS DISABLED FOR NOW. Use ordqz instead.
    
        Specifies whether the upper eigenvalues should be sorted.  A callable
        may be passed that, given a eigenvalue, returns a boolean denoting
        whether the eigenvalue should be sorted to the top-left (True). For
        real matrix pairs, the sort function takes three real arguments
        (alphar, alphai, beta). The eigenvalue
        ``x = (alphar + alphai*1j)/beta``.  For complex matrix pairs or
        output='complex', the sort function takes two complex arguments
        (alpha, beta). The eigenvalue ``x = (alpha/beta)``.  Alternatively,
        string parameters may be used:
    
            - 'lhp'   Left-hand plane (x.real < 0.0)
            - 'rhp'   Right-hand plane (x.real > 0.0)
            - 'iuc'   Inside the unit circle (x*x.conjugate() < 1.0)
            - 'ouc'   Outside the unit circle (x*x.conjugate() > 1.0)
    
        Defaults to None (no sorting).
    overwrite_a : bool, optional
        Whether to overwrite data in a (may improve performance)
    overwrite_b : bool, optional
        Whether to overwrite data in b (may improve performance)
    check_finite : bool, optional
        If true checks the elements of `A` and `B` are finite numbers. If
        false does no checking and passes matrix through to
        underlying algorithm.
    
    Returns
    -------
    AA : (N, N) ndarray
        Generalized Schur form of A.
    BB : (N, N) ndarray
        Generalized Schur form of B.
    Q : (N, N) ndarray
        The left Schur vectors.
    Z : (N, N) ndarray
        The right Schur vectors.
    
    Notes
    -----
    Q is transposed versus the equivalent function in Matlab.
    
    .. versionadded:: 0.11.0
    
    Examples
    --------
    >>> from scipy import linalg
    >>> np.random.seed(1234)
    >>> A = np.arange(9).reshape((3, 3))
    >>> B = np.random.randn(3, 3)
    
    >>> AA, BB, Q, Z = linalg.qz(A, B)
    >>> AA
    array([[-13.40928183,  -4.62471562,   1.09215523],
           [  0.        ,   0.        ,   1.22805978],
           [  0.        ,   0.        ,   0.31973817]])
    >>> BB
    array([[ 0.33362547, -1.37393632,  0.02179805],
           [ 0.        ,  1.68144922,  0.74683866],
           [ 0.        ,  0.        ,  0.9258294 ]])
    >>> Q
    array([[ 0.14134727, -0.97562773,  0.16784365],
           [ 0.49835904, -0.07636948, -0.86360059],
           [ 0.85537081,  0.20571399,  0.47541828]])
    >>> Z
    array([[-0.24900855, -0.51772687,  0.81850696],
           [-0.79813178,  0.58842606,  0.12938478],
           [-0.54861681, -0.6210585 , -0.55973739]])
    
    See also
    --------
    ordqz
",function,"('A', 'B', 'output', 'lwork', 'sort', 'overwrite_a', 'overwrite_b', 'check_finite')","(nan, nan, 'real', None, None, False, False, True)","(nan, nan, 'str', 'NoneType', 'NoneType', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(A, B, output='real', lwork=None, sort=None, overwrite_a=False, overwrite_b=False, check_finite=True)"",)"
scipy,1.1.0,scipy.linalg._decomp_update.LinAlgError,linalg._decomp_update,LinAlgError,"Python Library Documentation: class LinAlgError in module numpy.linalg.linalg

class LinAlgError(builtins.Exception)
 |  Generic Python-exception-derived object raised by linalg functions.
 |  
 |  General purpose exception class, derived from Python's exception.Exception
 |  class, programmatically raised in linalg functions when a Linear
 |  Algebra-related condition would prevent further correct execution of the
 |  function.
 |  
 |  Parameters
 |  ----------
 |  None
 |  
 |  Examples
 |  --------
 |  >>> from numpy import linalg as LA
 |  >>> LA.inv(np.zeros((2,2)))
 |  Traceback (most recent call last):
 |    File ""<stdin>"", line 1, in <module>
 |    File ""...linalg.py"", line 350,
 |      in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
 |    File ""...linalg.py"", line 249,
 |      in solve
 |      raise LinAlgError('Singular matrix')
 |  numpy.linalg.LinAlgError: Singular matrix
 |  
 |  Method resolution order:
 |      LinAlgError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg._decomp_update.LinAlgError,linalg._decomp_update,LinAlgError,"Python Library Documentation: class LinAlgError in module numpy.linalg.linalg

class LinAlgError(builtins.Exception)
 |  Generic Python-exception-derived object raised by linalg functions.
 |  
 |  General purpose exception class, derived from Python's exception.Exception
 |  class, programmatically raised in linalg functions when a Linear
 |  Algebra-related condition would prevent further correct execution of the
 |  function.
 |  
 |  Parameters
 |  ----------
 |  None
 |  
 |  Examples
 |  --------
 |  >>> from numpy import linalg as LA
 |  >>> LA.inv(np.zeros((2,2)))
 |  Traceback (most recent call last):
 |    File ""<stdin>"", line 1, in <module>
 |    File ""...linalg.py"", line 350,
 |      in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
 |    File ""...linalg.py"", line 249,
 |      in solve
 |      raise LinAlgError('Singular matrix')
 |  numpy.linalg.LinAlgError: Singular matrix
 |  
 |  Method resolution order:
 |      LinAlgError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg._expm_frechet._diff_pade3,linalg._expm_frechet,_diff_pade3,"Python Library Documentation: function _diff_pade3 in module scipy.linalg._expm_frechet

_diff_pade3(A, E, ident)
",function,"('(A, E, ident)',)",scipy,1.1.0,scipy.linalg._expm_frechet._diff_pade3,linalg._expm_frechet,_diff_pade3,"Python Library Documentation: function _diff_pade3 in module scipy.linalg._expm_frechet

_diff_pade3(A, E, ident)
",function,"('A', 'E', 'ident')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(A, E, ident)',)"
scipy,1.1.0,scipy.linalg._expm_frechet._diff_pade5,linalg._expm_frechet,_diff_pade5,"Python Library Documentation: function _diff_pade5 in module scipy.linalg._expm_frechet

_diff_pade5(A, E, ident)
",function,"('(A, E, ident)',)",scipy,1.1.0,scipy.linalg._expm_frechet._diff_pade5,linalg._expm_frechet,_diff_pade5,"Python Library Documentation: function _diff_pade5 in module scipy.linalg._expm_frechet

_diff_pade5(A, E, ident)
",function,"('A', 'E', 'ident')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(A, E, ident)',)"
scipy,1.1.0,scipy.linalg._expm_frechet._diff_pade7,linalg._expm_frechet,_diff_pade7,"Python Library Documentation: function _diff_pade7 in module scipy.linalg._expm_frechet

_diff_pade7(A, E, ident)
",function,"('(A, E, ident)',)",scipy,1.1.0,scipy.linalg._expm_frechet._diff_pade7,linalg._expm_frechet,_diff_pade7,"Python Library Documentation: function _diff_pade7 in module scipy.linalg._expm_frechet

_diff_pade7(A, E, ident)
",function,"('A', 'E', 'ident')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(A, E, ident)',)"
scipy,1.1.0,scipy.linalg._expm_frechet._diff_pade9,linalg._expm_frechet,_diff_pade9,"Python Library Documentation: function _diff_pade9 in module scipy.linalg._expm_frechet

_diff_pade9(A, E, ident)
",function,"('(A, E, ident)',)",scipy,1.1.0,scipy.linalg._expm_frechet._diff_pade9,linalg._expm_frechet,_diff_pade9,"Python Library Documentation: function _diff_pade9 in module scipy.linalg._expm_frechet

_diff_pade9(A, E, ident)
",function,"('A', 'E', 'ident')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(A, E, ident)',)"
scipy,1.1.0,scipy.linalg._expm_frechet.expm_cond,linalg._expm_frechet,expm_cond,"Python Library Documentation: function expm_cond in module scipy.linalg._expm_frechet

expm_cond(A, check_finite=True)
    Relative condition number of the matrix exponential in the Frobenius norm.
    
    Parameters
    ----------
    A : 2d array_like
        Square input matrix with shape (N, N).
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    kappa : float
        The relative condition number of the matrix exponential
        in the Frobenius norm
    
    Notes
    -----
    A faster estimate for the condition number in the 1-norm
    has been published but is not yet implemented in scipy.
    
    .. versionadded:: 0.14.0
    
    See also
    --------
    expm : Compute the exponential of a matrix.
    expm_frechet : Compute the Frechet derivative of the matrix exponential.
    
    Examples
    --------
    >>> from scipy.linalg import expm_cond
    >>> A = np.array([[-0.3, 0.2, 0.6], [0.6, 0.3, -0.1], [-0.7, 1.2, 0.9]])
    >>> k = expm_cond(A)
    >>> k
    1.7787805864469866
",function,"('(A, check_finite=True)',)",scipy,1.1.0,scipy.linalg._expm_frechet.expm_cond,linalg._expm_frechet,expm_cond,"Python Library Documentation: function expm_cond in module scipy.linalg._expm_frechet

expm_cond(A, check_finite=True)
    Relative condition number of the matrix exponential in the Frobenius norm.
    
    Parameters
    ----------
    A : 2d array_like
        Square input matrix with shape (N, N).
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    kappa : float
        The relative condition number of the matrix exponential
        in the Frobenius norm
    
    Notes
    -----
    A faster estimate for the condition number in the 1-norm
    has been published but is not yet implemented in scipy.
    
    .. versionadded:: 0.14.0
    
    See also
    --------
    expm : Compute the exponential of a matrix.
    expm_frechet : Compute the Frechet derivative of the matrix exponential.
    
    Examples
    --------
    >>> from scipy.linalg import expm_cond
    >>> A = np.array([[-0.3, 0.2, 0.6], [0.6, 0.3, -0.1], [-0.7, 1.2, 0.9]])
    >>> k = expm_cond(A)
    >>> k
    1.7787805864469866
",function,"('A', 'check_finite')","(nan, True)","(nan, 'bool')","('arg_info', 'arg_info')","('(A, check_finite=True)',)"
scipy,1.1.0,scipy.linalg._expm_frechet.expm_frechet,linalg._expm_frechet,expm_frechet,"Python Library Documentation: function expm_frechet in module scipy.linalg._expm_frechet

expm_frechet(A, E, method=None, compute_expm=True, check_finite=True)
    Frechet derivative of the matrix exponential of A in the direction E.
    
    Parameters
    ----------
    A : (N, N) array_like
        Matrix of which to take the matrix exponential.
    E : (N, N) array_like
        Matrix direction in which to take the Frechet derivative.
    method : str, optional
        Choice of algorithm.  Should be one of
    
        - `SPS` (default)
        - `blockEnlarge`
    
    compute_expm : bool, optional
        Whether to compute also `expm_A` in addition to `expm_frechet_AE`.
        Default is True.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    expm_A : ndarray
        Matrix exponential of A.
    expm_frechet_AE : ndarray
        Frechet derivative of the matrix exponential of A in the direction E.
    
    For ``compute_expm = False``, only `expm_frechet_AE` is returned.
    
    See also
    --------
    expm : Compute the exponential of a matrix.
    
    Notes
    -----
    This section describes the available implementations that can be selected
    by the `method` parameter. The default method is *SPS*.
    
    Method *blockEnlarge* is a naive algorithm.
    
    Method *SPS* is Scaling-Pade-Squaring [1]_.
    It is a sophisticated implementation which should take
    only about 3/8 as much time as the naive implementation.
    The asymptotics are the same.
    
    .. versionadded:: 0.13.0
    
    References
    ----------
    .. [1] Awad H. Al-Mohy and Nicholas J. Higham (2009)
           Computing the Frechet Derivative of the Matrix Exponential,
           with an application to Condition Number Estimation.
           SIAM Journal On Matrix Analysis and Applications.,
           30 (4). pp. 1639-1657. ISSN 1095-7162
    
    Examples
    --------
    >>> import scipy.linalg
    >>> A = np.random.randn(3, 3)
    >>> E = np.random.randn(3, 3)
    >>> expm_A, expm_frechet_AE = scipy.linalg.expm_frechet(A, E)
    >>> expm_A.shape, expm_frechet_AE.shape
    ((3, 3), (3, 3))
    
    >>> import scipy.linalg
    >>> A = np.random.randn(3, 3)
    >>> E = np.random.randn(3, 3)
    >>> expm_A, expm_frechet_AE = scipy.linalg.expm_frechet(A, E)
    >>> M = np.zeros((6, 6))
    >>> M[:3, :3] = A; M[:3, 3:] = E; M[3:, 3:] = A
    >>> expm_M = scipy.linalg.expm(M)
    >>> np.allclose(expm_A, expm_M[:3, :3])
    True
    >>> np.allclose(expm_frechet_AE, expm_M[:3, 3:])
    True
",function,"('(A, E, method=None, compute_expm=True, check_finite=True)',)",scipy,1.1.0,scipy.linalg._expm_frechet.expm_frechet,linalg._expm_frechet,expm_frechet,"Python Library Documentation: function expm_frechet in module scipy.linalg._expm_frechet

expm_frechet(A, E, method=None, compute_expm=True, check_finite=True)
    Frechet derivative of the matrix exponential of A in the direction E.
    
    Parameters
    ----------
    A : (N, N) array_like
        Matrix of which to take the matrix exponential.
    E : (N, N) array_like
        Matrix direction in which to take the Frechet derivative.
    method : str, optional
        Choice of algorithm.  Should be one of
    
        - `SPS` (default)
        - `blockEnlarge`
    
    compute_expm : bool, optional
        Whether to compute also `expm_A` in addition to `expm_frechet_AE`.
        Default is True.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    expm_A : ndarray
        Matrix exponential of A.
    expm_frechet_AE : ndarray
        Frechet derivative of the matrix exponential of A in the direction E.
    
    For ``compute_expm = False``, only `expm_frechet_AE` is returned.
    
    See also
    --------
    expm : Compute the exponential of a matrix.
    
    Notes
    -----
    This section describes the available implementations that can be selected
    by the `method` parameter. The default method is *SPS*.
    
    Method *blockEnlarge* is a naive algorithm.
    
    Method *SPS* is Scaling-Pade-Squaring [1]_.
    It is a sophisticated implementation which should take
    only about 3/8 as much time as the naive implementation.
    The asymptotics are the same.
    
    .. versionadded:: 0.13.0
    
    References
    ----------
    .. [1] Awad H. Al-Mohy and Nicholas J. Higham (2009)
           Computing the Frechet Derivative of the Matrix Exponential,
           with an application to Condition Number Estimation.
           SIAM Journal On Matrix Analysis and Applications.,
           30 (4). pp. 1639-1657. ISSN 1095-7162
    
    Examples
    --------
    >>> import scipy.linalg
    >>> A = np.random.randn(3, 3)
    >>> E = np.random.randn(3, 3)
    >>> expm_A, expm_frechet_AE = scipy.linalg.expm_frechet(A, E)
    >>> expm_A.shape, expm_frechet_AE.shape
    ((3, 3), (3, 3))
    
    >>> import scipy.linalg
    >>> A = np.random.randn(3, 3)
    >>> E = np.random.randn(3, 3)
    >>> expm_A, expm_frechet_AE = scipy.linalg.expm_frechet(A, E)
    >>> M = np.zeros((6, 6))
    >>> M[:3, :3] = A; M[:3, 3:] = E; M[3:, 3:] = A
    >>> expm_M = scipy.linalg.expm(M)
    >>> np.allclose(expm_A, expm_M[:3, :3])
    True
    >>> np.allclose(expm_frechet_AE, expm_M[:3, 3:])
    True
",function,"('A', 'E', 'method', 'compute_expm', 'check_finite')","(nan, nan, None, True, True)","(nan, nan, 'NoneType', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(A, E, method=None, compute_expm=True, check_finite=True)',)"
scipy,1.1.0,scipy.linalg._expm_frechet.expm_frechet_algo_64,linalg._expm_frechet,expm_frechet_algo_64,"Python Library Documentation: function expm_frechet_algo_64 in module scipy.linalg._expm_frechet

expm_frechet_algo_64(A, E)
",function,"('(A, E)',)",scipy,1.1.0,scipy.linalg._expm_frechet.expm_frechet_algo_64,linalg._expm_frechet,expm_frechet_algo_64,"Python Library Documentation: function expm_frechet_algo_64 in module scipy.linalg._expm_frechet

expm_frechet_algo_64(A, E)
",function,"('A', 'E')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(A, E)',)"
scipy,1.1.0,scipy.linalg._expm_frechet.expm_frechet_block_enlarge,linalg._expm_frechet,expm_frechet_block_enlarge,"Python Library Documentation: function expm_frechet_block_enlarge in module scipy.linalg._expm_frechet

expm_frechet_block_enlarge(A, E)
    This is a helper function, mostly for testing and profiling.
    Return expm(A), frechet(A, E)
",function,"('(A, E)',)",scipy,1.1.0,scipy.linalg._expm_frechet.expm_frechet_block_enlarge,linalg._expm_frechet,expm_frechet_block_enlarge,"Python Library Documentation: function expm_frechet_block_enlarge in module scipy.linalg._expm_frechet

expm_frechet_block_enlarge(A, E)
    This is a helper function, mostly for testing and profiling.
    Return expm(A), frechet(A, E)
",function,"('A', 'E')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(A, E)',)"
scipy,1.1.0,scipy.linalg._expm_frechet.expm_frechet_kronform,linalg._expm_frechet,expm_frechet_kronform,"Python Library Documentation: function expm_frechet_kronform in module scipy.linalg._expm_frechet

expm_frechet_kronform(A, method=None, check_finite=True)
    Construct the Kronecker form of the Frechet derivative of expm.
    
    Parameters
    ----------
    A : array_like with shape (N, N)
        Matrix to be expm'd.
    method : str, optional
        Extra keyword to be passed to expm_frechet.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    K : 2d ndarray with shape (N*N, N*N)
        Kronecker form of the Frechet derivative of the matrix exponential.
    
    Notes
    -----
    This function is used to help compute the condition number
    of the matrix exponential.
    
    See also
    --------
    expm : Compute a matrix exponential.
    expm_frechet : Compute the Frechet derivative of the matrix exponential.
    expm_cond : Compute the relative condition number of the matrix exponential
                in the Frobenius norm.
",function,"('(A, method=None, check_finite=True)',)",scipy,1.1.0,scipy.linalg._expm_frechet.expm_frechet_kronform,linalg._expm_frechet,expm_frechet_kronform,"Python Library Documentation: function expm_frechet_kronform in module scipy.linalg._expm_frechet

expm_frechet_kronform(A, method=None, check_finite=True)
    Construct the Kronecker form of the Frechet derivative of expm.
    
    Parameters
    ----------
    A : array_like with shape (N, N)
        Matrix to be expm'd.
    method : str, optional
        Extra keyword to be passed to expm_frechet.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    K : 2d ndarray with shape (N*N, N*N)
        Kronecker form of the Frechet derivative of the matrix exponential.
    
    Notes
    -----
    This function is used to help compute the condition number
    of the matrix exponential.
    
    See also
    --------
    expm : Compute a matrix exponential.
    expm_frechet : Compute the Frechet derivative of the matrix exponential.
    expm_cond : Compute the relative condition number of the matrix exponential
                in the Frobenius norm.
",function,"('A', 'method', 'check_finite')","(nan, None, True)","(nan, 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info')","('(A, method=None, check_finite=True)',)"
scipy,1.1.0,scipy.linalg._expm_frechet.vec,linalg._expm_frechet,vec,"Python Library Documentation: function vec in module scipy.linalg._expm_frechet

vec(M)
    Stack columns of M to construct a single vector.
    
    This is somewhat standard notation in linear algebra.
    
    Parameters
    ----------
    M : 2d array_like
        Input matrix
    
    Returns
    -------
    v : 1d ndarray
        Output vector
",function,"('(M)',)",scipy,1.1.0,scipy.linalg._expm_frechet.vec,linalg._expm_frechet,vec,"Python Library Documentation: function vec in module scipy.linalg._expm_frechet

vec(M)
    Stack columns of M to construct a single vector.
    
    This is somewhat standard notation in linear algebra.
    
    Parameters
    ----------
    M : 2d array_like
        Input matrix
    
    Returns
    -------
    v : 1d ndarray
        Output vector
",function,"('M',)","(nan,)","(nan,)","('arg_info',)","('(M)',)"
scipy,1.1.0,scipy.linalg._flapack.cgegv,linalg._flapack,cgegv,"Python Library Documentation: function cgegv in module numpy.lib.utils

cgegv(*args, **kwds)
    `cgegv` is deprecated!
    The `*gegv` family of routines has been deprecated in
    LAPACK 3.6.0 in favor of the `*ggev` family of routines.
    The corresponding wrappers will be removed from SciPy in
    a future release.
    
    alpha,beta,vl,vr,info = cgegv(a,b,[compute_vl,compute_vr,lwork,overwrite_a,overwrite_b])
    
    Wrapper for ``cgegv``.
    
    Parameters
    ----------
    a : input rank-2 array('F') with bounds (n,n)
    b : input rank-2 array('F') with bounds (n,n)
    
    Other Parameters
    ----------------
    compute_vl : input int, optional
        Default: 1
    compute_vr : input int, optional
        Default: 1
    overwrite_a : input int, optional
        Default: 0
    overwrite_b : input int, optional
        Default: 0
    lwork : input int, optional
        Default: max(2*n,1)
    
    Returns
    -------
    alpha : rank-1 array('F') with bounds (n)
    beta : rank-1 array('F') with bounds (n)
    vl : rank-2 array('F') with bounds (ldvl,n)
    vr : rank-2 array('F') with bounds (ldvr,n)
    info : int
",function,"('(*args, **kwds)',)",scipy,1.1.0,scipy.linalg._flapack.cgegv,linalg._flapack,cgegv,"Python Library Documentation: function cgegv in module numpy.lib.utils

cgegv(*args, **kwds)
    `cgegv` is deprecated!
    The `*gegv` family of routines has been deprecated in
    LAPACK 3.6.0 in favor of the `*ggev` family of routines.
    The corresponding wrappers will be removed from SciPy in
    a future release.
    
    alpha,beta,vl,vr,info = cgegv(a,b,[compute_vl,compute_vr,lwork,overwrite_a,overwrite_b])
    
    Wrapper for ``cgegv``.
    
    Parameters
    ----------
    a : input rank-2 array('F') with bounds (n,n)
    b : input rank-2 array('F') with bounds (n,n)
    
    Other Parameters
    ----------------
    compute_vl : input int, optional
        Default: 1
    compute_vr : input int, optional
        Default: 1
    overwrite_a : input int, optional
        Default: 0
    overwrite_b : input int, optional
        Default: 0
    lwork : input int, optional
        Default: max(2*n,1)
    
    Returns
    -------
    alpha : rank-1 array('F') with bounds (n)
    beta : rank-1 array('F') with bounds (n)
    vl : rank-2 array('F') with bounds (ldvl,n)
    vr : rank-2 array('F') with bounds (ldvr,n)
    info : int
",function,(),(),(),(),"('(*args, **kwds)',)"
scipy,1.1.0,scipy.linalg._flapack.dgegv,linalg._flapack,dgegv,"Python Library Documentation: function dgegv in module numpy.lib.utils

dgegv(*args, **kwds)
    `dgegv` is deprecated!
    The `*gegv` family of routines has been deprecated in
    LAPACK 3.6.0 in favor of the `*ggev` family of routines.
    The corresponding wrappers will be removed from SciPy in
    a future release.
    
    alphar,alphai,beta,vl,vr,info = dgegv(a,b,[compute_vl,compute_vr,lwork,overwrite_a,overwrite_b])
    
    Wrapper for ``dgegv``.
    
    Parameters
    ----------
    a : input rank-2 array('d') with bounds (n,n)
    b : input rank-2 array('d') with bounds (n,n)
    
    Other Parameters
    ----------------
    compute_vl : input int, optional
        Default: 1
    compute_vr : input int, optional
        Default: 1
    overwrite_a : input int, optional
        Default: 0
    overwrite_b : input int, optional
        Default: 0
    lwork : input int, optional
        Default: max(8*n,1)
    
    Returns
    -------
    alphar : rank-1 array('d') with bounds (n)
    alphai : rank-1 array('d') with bounds (n)
    beta : rank-1 array('d') with bounds (n)
    vl : rank-2 array('d') with bounds (ldvl,n)
    vr : rank-2 array('d') with bounds (ldvr,n)
    info : int
",function,"('(*args, **kwds)',)",scipy,1.1.0,scipy.linalg._flapack.dgegv,linalg._flapack,dgegv,"Python Library Documentation: function dgegv in module numpy.lib.utils

dgegv(*args, **kwds)
    `dgegv` is deprecated!
    The `*gegv` family of routines has been deprecated in
    LAPACK 3.6.0 in favor of the `*ggev` family of routines.
    The corresponding wrappers will be removed from SciPy in
    a future release.
    
    alphar,alphai,beta,vl,vr,info = dgegv(a,b,[compute_vl,compute_vr,lwork,overwrite_a,overwrite_b])
    
    Wrapper for ``dgegv``.
    
    Parameters
    ----------
    a : input rank-2 array('d') with bounds (n,n)
    b : input rank-2 array('d') with bounds (n,n)
    
    Other Parameters
    ----------------
    compute_vl : input int, optional
        Default: 1
    compute_vr : input int, optional
        Default: 1
    overwrite_a : input int, optional
        Default: 0
    overwrite_b : input int, optional
        Default: 0
    lwork : input int, optional
        Default: max(8*n,1)
    
    Returns
    -------
    alphar : rank-1 array('d') with bounds (n)
    alphai : rank-1 array('d') with bounds (n)
    beta : rank-1 array('d') with bounds (n)
    vl : rank-2 array('d') with bounds (ldvl,n)
    vr : rank-2 array('d') with bounds (ldvr,n)
    info : int
",function,(),(),(),(),"('(*args, **kwds)',)"
scipy,1.1.0,scipy.linalg._flapack.sgegv,linalg._flapack,sgegv,"Python Library Documentation: function sgegv in module numpy.lib.utils

sgegv(*args, **kwds)
    `sgegv` is deprecated!
    The `*gegv` family of routines has been deprecated in
    LAPACK 3.6.0 in favor of the `*ggev` family of routines.
    The corresponding wrappers will be removed from SciPy in
    a future release.
    
    alphar,alphai,beta,vl,vr,info = sgegv(a,b,[compute_vl,compute_vr,lwork,overwrite_a,overwrite_b])
    
    Wrapper for ``sgegv``.
    
    Parameters
    ----------
    a : input rank-2 array('f') with bounds (n,n)
    b : input rank-2 array('f') with bounds (n,n)
    
    Other Parameters
    ----------------
    compute_vl : input int, optional
        Default: 1
    compute_vr : input int, optional
        Default: 1
    overwrite_a : input int, optional
        Default: 0
    overwrite_b : input int, optional
        Default: 0
    lwork : input int, optional
        Default: max(8*n,1)
    
    Returns
    -------
    alphar : rank-1 array('f') with bounds (n)
    alphai : rank-1 array('f') with bounds (n)
    beta : rank-1 array('f') with bounds (n)
    vl : rank-2 array('f') with bounds (ldvl,n)
    vr : rank-2 array('f') with bounds (ldvr,n)
    info : int
",function,"('(*args, **kwds)',)",scipy,1.1.0,scipy.linalg._flapack.sgegv,linalg._flapack,sgegv,"Python Library Documentation: function sgegv in module numpy.lib.utils

sgegv(*args, **kwds)
    `sgegv` is deprecated!
    The `*gegv` family of routines has been deprecated in
    LAPACK 3.6.0 in favor of the `*ggev` family of routines.
    The corresponding wrappers will be removed from SciPy in
    a future release.
    
    alphar,alphai,beta,vl,vr,info = sgegv(a,b,[compute_vl,compute_vr,lwork,overwrite_a,overwrite_b])
    
    Wrapper for ``sgegv``.
    
    Parameters
    ----------
    a : input rank-2 array('f') with bounds (n,n)
    b : input rank-2 array('f') with bounds (n,n)
    
    Other Parameters
    ----------------
    compute_vl : input int, optional
        Default: 1
    compute_vr : input int, optional
        Default: 1
    overwrite_a : input int, optional
        Default: 0
    overwrite_b : input int, optional
        Default: 0
    lwork : input int, optional
        Default: max(8*n,1)
    
    Returns
    -------
    alphar : rank-1 array('f') with bounds (n)
    alphai : rank-1 array('f') with bounds (n)
    beta : rank-1 array('f') with bounds (n)
    vl : rank-2 array('f') with bounds (ldvl,n)
    vr : rank-2 array('f') with bounds (ldvr,n)
    info : int
",function,(),(),(),(),"('(*args, **kwds)',)"
scipy,1.1.0,scipy.linalg._flapack.zgegv,linalg._flapack,zgegv,"Python Library Documentation: function zgegv in module numpy.lib.utils

zgegv(*args, **kwds)
    `zgegv` is deprecated!
    The `*gegv` family of routines has been deprecated in
    LAPACK 3.6.0 in favor of the `*ggev` family of routines.
    The corresponding wrappers will be removed from SciPy in
    a future release.
    
    alpha,beta,vl,vr,info = zgegv(a,b,[compute_vl,compute_vr,lwork,overwrite_a,overwrite_b])
    
    Wrapper for ``zgegv``.
    
    Parameters
    ----------
    a : input rank-2 array('D') with bounds (n,n)
    b : input rank-2 array('D') with bounds (n,n)
    
    Other Parameters
    ----------------
    compute_vl : input int, optional
        Default: 1
    compute_vr : input int, optional
        Default: 1
    overwrite_a : input int, optional
        Default: 0
    overwrite_b : input int, optional
        Default: 0
    lwork : input int, optional
        Default: max(2*n,1)
    
    Returns
    -------
    alpha : rank-1 array('D') with bounds (n)
    beta : rank-1 array('D') with bounds (n)
    vl : rank-2 array('D') with bounds (ldvl,n)
    vr : rank-2 array('D') with bounds (ldvr,n)
    info : int
",function,"('(*args, **kwds)',)",scipy,1.1.0,scipy.linalg._flapack.zgegv,linalg._flapack,zgegv,"Python Library Documentation: function zgegv in module numpy.lib.utils

zgegv(*args, **kwds)
    `zgegv` is deprecated!
    The `*gegv` family of routines has been deprecated in
    LAPACK 3.6.0 in favor of the `*ggev` family of routines.
    The corresponding wrappers will be removed from SciPy in
    a future release.
    
    alpha,beta,vl,vr,info = zgegv(a,b,[compute_vl,compute_vr,lwork,overwrite_a,overwrite_b])
    
    Wrapper for ``zgegv``.
    
    Parameters
    ----------
    a : input rank-2 array('D') with bounds (n,n)
    b : input rank-2 array('D') with bounds (n,n)
    
    Other Parameters
    ----------------
    compute_vl : input int, optional
        Default: 1
    compute_vr : input int, optional
        Default: 1
    overwrite_a : input int, optional
        Default: 0
    overwrite_b : input int, optional
        Default: 0
    lwork : input int, optional
        Default: max(2*n,1)
    
    Returns
    -------
    alpha : rank-1 array('D') with bounds (n)
    beta : rank-1 array('D') with bounds (n)
    vl : rank-2 array('D') with bounds (ldvl,n)
    vr : rank-2 array('D') with bounds (ldvr,n)
    info : int
",function,(),(),(),(),"('(*args, **kwds)',)"
scipy,1.1.0,scipy.linalg._matfuncs_sqrtm.SqrtmError,linalg._matfuncs_sqrtm,SqrtmError,"Python Library Documentation: class SqrtmError in module scipy.linalg._matfuncs_sqrtm

class SqrtmError(numpy.linalg.linalg.LinAlgError)
 |  Generic Python-exception-derived object raised by linalg functions.
 |  
 |  General purpose exception class, derived from Python's exception.Exception
 |  class, programmatically raised in linalg functions when a Linear
 |  Algebra-related condition would prevent further correct execution of the
 |  function.
 |  
 |  Parameters
 |  ----------
 |  None
 |  
 |  Examples
 |  --------
 |  >>> from numpy import linalg as LA
 |  >>> LA.inv(np.zeros((2,2)))
 |  Traceback (most recent call last):
 |    File ""<stdin>"", line 1, in <module>
 |    File ""...linalg.py"", line 350,
 |      in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
 |    File ""...linalg.py"", line 249,
 |      in solve
 |      raise LinAlgError('Singular matrix')
 |  numpy.linalg.LinAlgError: Singular matrix
 |  
 |  Method resolution order:
 |      SqrtmError
 |      numpy.linalg.linalg.LinAlgError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors inherited from numpy.linalg.linalg.LinAlgError:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg._matfuncs_sqrtm.SqrtmError,linalg._matfuncs_sqrtm,SqrtmError,"Python Library Documentation: class SqrtmError in module scipy.linalg._matfuncs_sqrtm

class SqrtmError(numpy.linalg.linalg.LinAlgError)
 |  Generic Python-exception-derived object raised by linalg functions.
 |  
 |  General purpose exception class, derived from Python's exception.Exception
 |  class, programmatically raised in linalg functions when a Linear
 |  Algebra-related condition would prevent further correct execution of the
 |  function.
 |  
 |  Parameters
 |  ----------
 |  None
 |  
 |  Examples
 |  --------
 |  >>> from numpy import linalg as LA
 |  >>> LA.inv(np.zeros((2,2)))
 |  Traceback (most recent call last):
 |    File ""<stdin>"", line 1, in <module>
 |    File ""...linalg.py"", line 350,
 |      in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
 |    File ""...linalg.py"", line 249,
 |      in solve
 |      raise LinAlgError('Singular matrix')
 |  numpy.linalg.LinAlgError: Singular matrix
 |  
 |  Method resolution order:
 |      SqrtmError
 |      numpy.linalg.linalg.LinAlgError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors inherited from numpy.linalg.linalg.LinAlgError:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg._matfuncs_sqrtm._asarray_validated,linalg._matfuncs_sqrtm,_asarray_validated,"Python Library Documentation: function _asarray_validated in module scipy._lib._util

_asarray_validated(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)
    Helper function for scipy argument validation.
    
    Many scipy linear algebra functions do support arbitrary array-like
    input arguments.  Examples of commonly unsupported inputs include
    matrices containing inf/nan, sparse matrix representations, and
    matrices with complicated elements.
    
    Parameters
    ----------
    a : array_like
        The array-like input.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default: True
    sparse_ok : bool, optional
        True if scipy sparse matrices are allowed.
    objects_ok : bool, optional
        True if arrays with dype('O') are allowed.
    mask_ok : bool, optional
        True if masked arrays are allowed.
    as_inexact : bool, optional
        True to convert the input array to a np.inexact dtype.
    
    Returns
    -------
    ret : ndarray
        The converted validated array.
",function,"('(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)',)",scipy,1.1.0,scipy.linalg._matfuncs_sqrtm._asarray_validated,linalg._matfuncs_sqrtm,_asarray_validated,"Python Library Documentation: function _asarray_validated in module scipy._lib._util

_asarray_validated(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)
    Helper function for scipy argument validation.
    
    Many scipy linear algebra functions do support arbitrary array-like
    input arguments.  Examples of commonly unsupported inputs include
    matrices containing inf/nan, sparse matrix representations, and
    matrices with complicated elements.
    
    Parameters
    ----------
    a : array_like
        The array-like input.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default: True
    sparse_ok : bool, optional
        True if scipy sparse matrices are allowed.
    objects_ok : bool, optional
        True if arrays with dype('O') are allowed.
    mask_ok : bool, optional
        True if masked arrays are allowed.
    as_inexact : bool, optional
        True to convert the input array to a np.inexact dtype.
    
    Returns
    -------
    ret : ndarray
        The converted validated array.
",function,"('a', 'check_finite', 'sparse_ok', 'objects_ok', 'mask_ok', 'as_inexact')","(nan, True, False, False, False, False)","(nan, 'bool', 'bool', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)',)"
scipy,1.1.0,scipy.linalg._matfuncs_sqrtm._sqrtm_triu,linalg._matfuncs_sqrtm,_sqrtm_triu,"Python Library Documentation: function _sqrtm_triu in module scipy.linalg._matfuncs_sqrtm

_sqrtm_triu(T, blocksize=64)
    Matrix square root of an upper triangular matrix.
    
    This is a helper function for `sqrtm` and `logm`.
    
    Parameters
    ----------
    T : (N, N) array_like upper triangular
        Matrix whose square root to evaluate
    blocksize : int, optional
        If the blocksize is not degenerate with respect to the
        size of the input array, then use a blocked algorithm. (Default: 64)
    
    Returns
    -------
    sqrtm : (N, N) ndarray
        Value of the sqrt function at `T`
    
    References
    ----------
    .. [1] Edvin Deadman, Nicholas J. Higham, Rui Ralha (2013)
           ""Blocked Schur Algorithms for Computing the Matrix Square Root,
           Lecture Notes in Computer Science, 7782. pp. 171-182.
",function,"('(T, blocksize=64)',)",scipy,1.1.0,scipy.linalg._matfuncs_sqrtm._sqrtm_triu,linalg._matfuncs_sqrtm,_sqrtm_triu,"Python Library Documentation: function _sqrtm_triu in module scipy.linalg._matfuncs_sqrtm

_sqrtm_triu(T, blocksize=64)
    Matrix square root of an upper triangular matrix.
    
    This is a helper function for `sqrtm` and `logm`.
    
    Parameters
    ----------
    T : (N, N) array_like upper triangular
        Matrix whose square root to evaluate
    blocksize : int, optional
        If the blocksize is not degenerate with respect to the
        size of the input array, then use a blocked algorithm. (Default: 64)
    
    Returns
    -------
    sqrtm : (N, N) ndarray
        Value of the sqrt function at `T`
    
    References
    ----------
    .. [1] Edvin Deadman, Nicholas J. Higham, Rui Ralha (2013)
           ""Blocked Schur Algorithms for Computing the Matrix Square Root,
           Lecture Notes in Computer Science, 7782. pp. 171-182.
",function,"('T', 'blocksize')","(nan, 64)","(nan, 'int')","('arg_info', 'arg_info')","('(T, blocksize=64)',)"
scipy,1.1.0,scipy.linalg._matfuncs_sqrtm.norm,linalg._matfuncs_sqrtm,norm,"Python Library Documentation: function norm in module scipy.linalg.misc

norm(a, ord=None, axis=None, keepdims=False)
    Matrix or vector norm.
    
    This function is able to return one of seven different matrix norms,
    or one of an infinite number of vector norms (described below), depending
    on the value of the ``ord`` parameter.
    
    Parameters
    ----------
    a : (M,) or (M, N) array_like
        Input array.  If `axis` is None, `a` must be 1-D or 2-D.
    ord : {non-zero int, inf, -inf, 'fro'}, optional
        Order of the norm (see table under ``Notes``). inf means numpy's
        `inf` object
    axis : {int, 2-tuple of ints, None}, optional
        If `axis` is an integer, it specifies the axis of `a` along which to
        compute the vector norms.  If `axis` is a 2-tuple, it specifies the
        axes that hold 2-D matrices, and the matrix norms of these matrices
        are computed.  If `axis` is None then either a vector norm (when `a`
        is 1-D) or a matrix norm (when `a` is 2-D) is returned.
    keepdims : bool, optional
        If this is set to True, the axes which are normed over are left in the
        result as dimensions with size one.  With this option the result will
        broadcast correctly against the original `a`.
    
    Returns
    -------
    n : float or ndarray
        Norm of the matrix or vector(s).
    
    Notes
    -----
    For values of ``ord <= 0``, the result is, strictly speaking, not a
    mathematical 'norm', but it may still be useful for various numerical
    purposes.
    
    The following norms can be calculated:
    
    =====  ============================  ==========================
    ord    norm for matrices             norm for vectors
    =====  ============================  ==========================
    None   Frobenius norm                2-norm
    'fro'  Frobenius norm                --
    inf    max(sum(abs(x), axis=1))      max(abs(x))
    -inf   min(sum(abs(x), axis=1))      min(abs(x))
    0      --                            sum(x != 0)
    1      max(sum(abs(x), axis=0))      as below
    -1     min(sum(abs(x), axis=0))      as below
    2      2-norm (largest sing. value)  as below
    -2     smallest singular value       as below
    other  --                            sum(abs(x)**ord)**(1./ord)
    =====  ============================  ==========================
    
    The Frobenius norm is given by [1]_:
    
        :math:`||A||_F = [\sum_{i,j} abs(a_{i,j})^2]^{1/2}`
    
    The ``axis`` and ``keepdims`` arguments are passed directly to
    ``numpy.linalg.norm`` and are only usable if they are supported
    by the version of numpy in use.
    
    References
    ----------
    .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*,
           Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15
    
    Examples
    --------
    >>> from scipy.linalg import norm
    >>> a = np.arange(9) - 4.0
    >>> a
    array([-4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.])
    >>> b = a.reshape((3, 3))
    >>> b
    array([[-4., -3., -2.],
           [-1.,  0.,  1.],
           [ 2.,  3.,  4.]])
    
    >>> norm(a)
    7.745966692414834
    >>> norm(b)
    7.745966692414834
    >>> norm(b, 'fro')
    7.745966692414834
    >>> norm(a, np.inf)
    4
    >>> norm(b, np.inf)
    9
    >>> norm(a, -np.inf)
    0
    >>> norm(b, -np.inf)
    2
    
    >>> norm(a, 1)
    20
    >>> norm(b, 1)
    7
    >>> norm(a, -1)
    -4.6566128774142013e-010
    >>> norm(b, -1)
    6
    >>> norm(a, 2)
    7.745966692414834
    >>> norm(b, 2)
    7.3484692283495345
    
    >>> norm(a, -2)
    0
    >>> norm(b, -2)
    1.8570331885190563e-016
    >>> norm(a, 3)
    5.8480354764257312
    >>> norm(a, -3)
    0
",function,"('(a, ord=None, axis=None, keepdims=False)',)",scipy,1.1.0,scipy.linalg._matfuncs_sqrtm.norm,linalg._matfuncs_sqrtm,norm,"Python Library Documentation: function norm in module scipy.linalg.misc

norm(a, ord=None, axis=None, keepdims=False)
    Matrix or vector norm.
    
    This function is able to return one of seven different matrix norms,
    or one of an infinite number of vector norms (described below), depending
    on the value of the ``ord`` parameter.
    
    Parameters
    ----------
    a : (M,) or (M, N) array_like
        Input array.  If `axis` is None, `a` must be 1-D or 2-D.
    ord : {non-zero int, inf, -inf, 'fro'}, optional
        Order of the norm (see table under ``Notes``). inf means numpy's
        `inf` object
    axis : {int, 2-tuple of ints, None}, optional
        If `axis` is an integer, it specifies the axis of `a` along which to
        compute the vector norms.  If `axis` is a 2-tuple, it specifies the
        axes that hold 2-D matrices, and the matrix norms of these matrices
        are computed.  If `axis` is None then either a vector norm (when `a`
        is 1-D) or a matrix norm (when `a` is 2-D) is returned.
    keepdims : bool, optional
        If this is set to True, the axes which are normed over are left in the
        result as dimensions with size one.  With this option the result will
        broadcast correctly against the original `a`.
    
    Returns
    -------
    n : float or ndarray
        Norm of the matrix or vector(s).
    
    Notes
    -----
    For values of ``ord <= 0``, the result is, strictly speaking, not a
    mathematical 'norm', but it may still be useful for various numerical
    purposes.
    
    The following norms can be calculated:
    
    =====  ============================  ==========================
    ord    norm for matrices             norm for vectors
    =====  ============================  ==========================
    None   Frobenius norm                2-norm
    'fro'  Frobenius norm                --
    inf    max(sum(abs(x), axis=1))      max(abs(x))
    -inf   min(sum(abs(x), axis=1))      min(abs(x))
    0      --                            sum(x != 0)
    1      max(sum(abs(x), axis=0))      as below
    -1     min(sum(abs(x), axis=0))      as below
    2      2-norm (largest sing. value)  as below
    -2     smallest singular value       as below
    other  --                            sum(abs(x)**ord)**(1./ord)
    =====  ============================  ==========================
    
    The Frobenius norm is given by [1]_:
    
        :math:`||A||_F = [\sum_{i,j} abs(a_{i,j})^2]^{1/2}`
    
    The ``axis`` and ``keepdims`` arguments are passed directly to
    ``numpy.linalg.norm`` and are only usable if they are supported
    by the version of numpy in use.
    
    References
    ----------
    .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*,
           Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15
    
    Examples
    --------
    >>> from scipy.linalg import norm
    >>> a = np.arange(9) - 4.0
    >>> a
    array([-4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.])
    >>> b = a.reshape((3, 3))
    >>> b
    array([[-4., -3., -2.],
           [-1.,  0.,  1.],
           [ 2.,  3.,  4.]])
    
    >>> norm(a)
    7.745966692414834
    >>> norm(b)
    7.745966692414834
    >>> norm(b, 'fro')
    7.745966692414834
    >>> norm(a, np.inf)
    4
    >>> norm(b, np.inf)
    9
    >>> norm(a, -np.inf)
    0
    >>> norm(b, -np.inf)
    2
    
    >>> norm(a, 1)
    20
    >>> norm(b, 1)
    7
    >>> norm(a, -1)
    -4.6566128774142013e-010
    >>> norm(b, -1)
    6
    >>> norm(a, 2)
    7.745966692414834
    >>> norm(b, 2)
    7.3484692283495345
    
    >>> norm(a, -2)
    0
    >>> norm(b, -2)
    1.8570331885190563e-016
    >>> norm(a, 3)
    5.8480354764257312
    >>> norm(a, -3)
    0
",function,"('a', 'ord', 'axis', 'keepdims')","(nan, None, None, False)","(nan, 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, ord=None, axis=None, keepdims=False)',)"
scipy,1.1.0,scipy.linalg._matfuncs_sqrtm.rsf2csf,linalg._matfuncs_sqrtm,rsf2csf,"Python Library Documentation: function rsf2csf in module scipy.linalg.decomp_schur

rsf2csf(T, Z, check_finite=True)
    Convert real Schur form to complex Schur form.
    
    Convert a quasi-diagonal real-valued Schur form to the upper triangular
    complex-valued Schur form.
    
    Parameters
    ----------
    T : (M, M) array_like
        Real Schur form of the original array
    Z : (M, M) array_like
        Schur transformation matrix
    check_finite : bool, optional
        Whether to check that the input arrays contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    T : (M, M) ndarray
        Complex Schur form of the original array
    Z : (M, M) ndarray
        Schur transformation matrix corresponding to the complex form
    
    See Also
    --------
    schur : Schur decomposition of an array
    
    Examples
    --------
    >>> from scipy.linalg import schur, rsf2csf
    >>> A = np.array([[0, 2, 2], [0, 1, 2], [1, 0, 1]])
    >>> T, Z = schur(A)
    >>> T
    array([[ 2.65896708,  1.42440458, -1.92933439],
           [ 0.        , -0.32948354, -0.49063704],
           [ 0.        ,  1.31178921, -0.32948354]])
    >>> Z
    array([[0.72711591, -0.60156188, 0.33079564],
           [0.52839428, 0.79801892, 0.28976765],
           [0.43829436, 0.03590414, -0.89811411]])
    >>> T2 , Z2 = rsf2csf(T, Z)
    >>> T2
    array([[2.65896708+0.j, -1.64592781+0.743164187j, -1.21516887+1.00660462j],
           [0.+0.j , -0.32948354+8.02254558e-01j, -0.82115218-2.77555756e-17j],
           [0.+0.j , 0.+0.j, -0.32948354-0.802254558j]])
    >>> Z2
    array([[0.72711591+0.j,  0.28220393-0.31385693j,  0.51319638-0.17258824j],
           [0.52839428+0.j,  0.24720268+0.41635578j, -0.68079517-0.15118243j],
           [0.43829436+0.j, -0.76618703+0.01873251j, -0.03063006+0.46857912j]])
",function,"('(T, Z, check_finite=True)',)",scipy,1.1.0,scipy.linalg._matfuncs_sqrtm.rsf2csf,linalg._matfuncs_sqrtm,rsf2csf,"Python Library Documentation: function rsf2csf in module scipy.linalg.decomp_schur

rsf2csf(T, Z, check_finite=True)
    Convert real Schur form to complex Schur form.
    
    Convert a quasi-diagonal real-valued Schur form to the upper triangular
    complex-valued Schur form.
    
    Parameters
    ----------
    T : (M, M) array_like
        Real Schur form of the original array
    Z : (M, M) array_like
        Schur transformation matrix
    check_finite : bool, optional
        Whether to check that the input arrays contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    T : (M, M) ndarray
        Complex Schur form of the original array
    Z : (M, M) ndarray
        Schur transformation matrix corresponding to the complex form
    
    See Also
    --------
    schur : Schur decomposition of an array
    
    Examples
    --------
    >>> from scipy.linalg import schur, rsf2csf
    >>> A = np.array([[0, 2, 2], [0, 1, 2], [1, 0, 1]])
    >>> T, Z = schur(A)
    >>> T
    array([[ 2.65896708,  1.42440458, -1.92933439],
           [ 0.        , -0.32948354, -0.49063704],
           [ 0.        ,  1.31178921, -0.32948354]])
    >>> Z
    array([[0.72711591, -0.60156188, 0.33079564],
           [0.52839428, 0.79801892, 0.28976765],
           [0.43829436, 0.03590414, -0.89811411]])
    >>> T2 , Z2 = rsf2csf(T, Z)
    >>> T2
    array([[2.65896708+0.j, -1.64592781+0.743164187j, -1.21516887+1.00660462j],
           [0.+0.j , -0.32948354+8.02254558e-01j, -0.82115218-2.77555756e-17j],
           [0.+0.j , 0.+0.j, -0.32948354-0.802254558j]])
    >>> Z2
    array([[0.72711591+0.j,  0.28220393-0.31385693j,  0.51319638-0.17258824j],
           [0.52839428+0.j,  0.24720268+0.41635578j, -0.68079517-0.15118243j],
           [0.43829436+0.j, -0.76618703+0.01873251j, -0.03063006+0.46857912j]])
",function,"('T', 'Z', 'check_finite')","(nan, nan, True)","(nan, nan, 'bool')","('arg_info', 'arg_info', 'arg_info')","('(T, Z, check_finite=True)',)"
scipy,1.1.0,scipy.linalg._matfuncs_sqrtm.schur,linalg._matfuncs_sqrtm,schur,"Python Library Documentation: function schur in module scipy.linalg.decomp_schur

schur(a, output='real', lwork=None, overwrite_a=False, sort=None, check_finite=True)
    Compute Schur decomposition of a matrix.
    
    The Schur decomposition is::
    
        A = Z T Z^H
    
    where Z is unitary and T is either upper-triangular, or for real
    Schur decomposition (output='real'), quasi-upper triangular.  In
    the quasi-triangular form, 2x2 blocks describing complex-valued
    eigenvalue pairs may extrude from the diagonal.
    
    Parameters
    ----------
    a : (M, M) array_like
        Matrix to decompose
    output : {'real', 'complex'}, optional
        Construct the real or complex Schur decomposition (for real matrices).
    lwork : int, optional
        Work array size. If None or -1, it is automatically computed.
    overwrite_a : bool, optional
        Whether to overwrite data in a (may improve performance).
    sort : {None, callable, 'lhp', 'rhp', 'iuc', 'ouc'}, optional
        Specifies whether the upper eigenvalues should be sorted.  A callable
        may be passed that, given a eigenvalue, returns a boolean denoting
        whether the eigenvalue should be sorted to the top-left (True).
        Alternatively, string parameters may be used::
    
            'lhp'   Left-hand plane (x.real < 0.0)
            'rhp'   Right-hand plane (x.real > 0.0)
            'iuc'   Inside the unit circle (x*x.conjugate() <= 1.0)
            'ouc'   Outside the unit circle (x*x.conjugate() > 1.0)
    
        Defaults to None (no sorting).
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    T : (M, M) ndarray
        Schur form of A. It is real-valued for the real Schur decomposition.
    Z : (M, M) ndarray
        An unitary Schur transformation matrix for A.
        It is real-valued for the real Schur decomposition.
    sdim : int
        If and only if sorting was requested, a third return value will
        contain the number of eigenvalues satisfying the sort condition.
    
    Raises
    ------
    LinAlgError
        Error raised under three conditions:
    
        1. The algorithm failed due to a failure of the QR algorithm to
           compute all eigenvalues
        2. If eigenvalue sorting was requested, the eigenvalues could not be
           reordered due to a failure to separate eigenvalues, usually because
           of poor conditioning
        3. If eigenvalue sorting was requested, roundoff errors caused the
           leading eigenvalues to no longer satisfy the sorting condition
    
    See also
    --------
    rsf2csf : Convert real Schur form to complex Schur form
    
    Examples
    --------
    >>> from scipy.linalg import schur, eigvals
    >>> A = np.array([[0, 2, 2], [0, 1, 2], [1, 0, 1]])
    >>> T, Z = schur(A)
    >>> T
    array([[ 2.65896708,  1.42440458, -1.92933439],
           [ 0.        , -0.32948354, -0.49063704],
           [ 0.        ,  1.31178921, -0.32948354]])
    >>> Z
    array([[0.72711591, -0.60156188, 0.33079564],
           [0.52839428, 0.79801892, 0.28976765],
           [0.43829436, 0.03590414, -0.89811411]])
    
    >>> T2, Z2 = schur(A, output='complex')
    >>> T2
    array([[ 2.65896708, -1.22839825+1.32378589j,  0.42590089+1.51937378j],
           [ 0.        , -0.32948354+0.80225456j, -0.59877807+0.56192146j],
           [ 0.        ,  0.                    , -0.32948354-0.80225456j]])
    >>> eigvals(T2)
    array([2.65896708, -0.32948354+0.80225456j, -0.32948354-0.80225456j])
    
    An arbitrary custom eig-sorting condition, having positive imaginary part, 
    which is satisfied by only one eigenvalue
    
    >>> T3, Z3, sdim = schur(A, output='complex', sort=lambda x: x.imag > 0)
    >>> sdim
    1
",function,"(""(a, output='real', lwork=None, overwrite_a=False, sort=None, check_finite=True)"",)",scipy,1.1.0,scipy.linalg._matfuncs_sqrtm.schur,linalg._matfuncs_sqrtm,schur,"Python Library Documentation: function schur in module scipy.linalg.decomp_schur

schur(a, output='real', lwork=None, overwrite_a=False, sort=None, check_finite=True)
    Compute Schur decomposition of a matrix.
    
    The Schur decomposition is::
    
        A = Z T Z^H
    
    where Z is unitary and T is either upper-triangular, or for real
    Schur decomposition (output='real'), quasi-upper triangular.  In
    the quasi-triangular form, 2x2 blocks describing complex-valued
    eigenvalue pairs may extrude from the diagonal.
    
    Parameters
    ----------
    a : (M, M) array_like
        Matrix to decompose
    output : {'real', 'complex'}, optional
        Construct the real or complex Schur decomposition (for real matrices).
    lwork : int, optional
        Work array size. If None or -1, it is automatically computed.
    overwrite_a : bool, optional
        Whether to overwrite data in a (may improve performance).
    sort : {None, callable, 'lhp', 'rhp', 'iuc', 'ouc'}, optional
        Specifies whether the upper eigenvalues should be sorted.  A callable
        may be passed that, given a eigenvalue, returns a boolean denoting
        whether the eigenvalue should be sorted to the top-left (True).
        Alternatively, string parameters may be used::
    
            'lhp'   Left-hand plane (x.real < 0.0)
            'rhp'   Right-hand plane (x.real > 0.0)
            'iuc'   Inside the unit circle (x*x.conjugate() <= 1.0)
            'ouc'   Outside the unit circle (x*x.conjugate() > 1.0)
    
        Defaults to None (no sorting).
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    T : (M, M) ndarray
        Schur form of A. It is real-valued for the real Schur decomposition.
    Z : (M, M) ndarray
        An unitary Schur transformation matrix for A.
        It is real-valued for the real Schur decomposition.
    sdim : int
        If and only if sorting was requested, a third return value will
        contain the number of eigenvalues satisfying the sort condition.
    
    Raises
    ------
    LinAlgError
        Error raised under three conditions:
    
        1. The algorithm failed due to a failure of the QR algorithm to
           compute all eigenvalues
        2. If eigenvalue sorting was requested, the eigenvalues could not be
           reordered due to a failure to separate eigenvalues, usually because
           of poor conditioning
        3. If eigenvalue sorting was requested, roundoff errors caused the
           leading eigenvalues to no longer satisfy the sorting condition
    
    See also
    --------
    rsf2csf : Convert real Schur form to complex Schur form
    
    Examples
    --------
    >>> from scipy.linalg import schur, eigvals
    >>> A = np.array([[0, 2, 2], [0, 1, 2], [1, 0, 1]])
    >>> T, Z = schur(A)
    >>> T
    array([[ 2.65896708,  1.42440458, -1.92933439],
           [ 0.        , -0.32948354, -0.49063704],
           [ 0.        ,  1.31178921, -0.32948354]])
    >>> Z
    array([[0.72711591, -0.60156188, 0.33079564],
           [0.52839428, 0.79801892, 0.28976765],
           [0.43829436, 0.03590414, -0.89811411]])
    
    >>> T2, Z2 = schur(A, output='complex')
    >>> T2
    array([[ 2.65896708, -1.22839825+1.32378589j,  0.42590089+1.51937378j],
           [ 0.        , -0.32948354+0.80225456j, -0.59877807+0.56192146j],
           [ 0.        ,  0.                    , -0.32948354-0.80225456j]])
    >>> eigvals(T2)
    array([2.65896708, -0.32948354+0.80225456j, -0.32948354-0.80225456j])
    
    An arbitrary custom eig-sorting condition, having positive imaginary part, 
    which is satisfied by only one eigenvalue
    
    >>> T3, Z3, sdim = schur(A, output='complex', sort=lambda x: x.imag > 0)
    >>> sdim
    1
",function,"('a', 'output', 'lwork', 'overwrite_a', 'sort', 'check_finite')","(nan, 'real', None, False, None, True)","(nan, 'str', 'NoneType', 'bool', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a, output='real', lwork=None, overwrite_a=False, sort=None, check_finite=True)"",)"
scipy,1.1.0,scipy.linalg._matfuncs_sqrtm.sqrtm,linalg._matfuncs_sqrtm,sqrtm,"Python Library Documentation: function sqrtm in module scipy.linalg._matfuncs_sqrtm

sqrtm(A, disp=True, blocksize=64)
    Matrix square root.
    
    Parameters
    ----------
    A : (N, N) array_like
        Matrix whose square root to evaluate
    disp : bool, optional
        Print warning if error in the result is estimated large
        instead of returning estimated error. (Default: True)
    blocksize : integer, optional
        If the blocksize is not degenerate with respect to the
        size of the input array, then use a blocked algorithm. (Default: 64)
    
    Returns
    -------
    sqrtm : (N, N) ndarray
        Value of the sqrt function at `A`
    
    errest : float
        (if disp == False)
    
        Frobenius norm of the estimated error, ||err||_F / ||A||_F
    
    References
    ----------
    .. [1] Edvin Deadman, Nicholas J. Higham, Rui Ralha (2013)
           ""Blocked Schur Algorithms for Computing the Matrix Square Root,
           Lecture Notes in Computer Science, 7782. pp. 171-182.
    
    Examples
    --------
    >>> from scipy.linalg import sqrtm
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> r = sqrtm(a)
    >>> r
    array([[ 0.75592895,  1.13389342],
           [ 0.37796447,  1.88982237]])
    >>> r.dot(r)
    array([[ 1.,  3.],
           [ 1.,  4.]])
",function,"('(A, disp=True, blocksize=64)',)",scipy,1.1.0,scipy.linalg._matfuncs_sqrtm.sqrtm,linalg._matfuncs_sqrtm,sqrtm,"Python Library Documentation: function sqrtm in module scipy.linalg._matfuncs_sqrtm

sqrtm(A, disp=True, blocksize=64)
    Matrix square root.
    
    Parameters
    ----------
    A : (N, N) array_like
        Matrix whose square root to evaluate
    disp : bool, optional
        Print warning if error in the result is estimated large
        instead of returning estimated error. (Default: True)
    blocksize : integer, optional
        If the blocksize is not degenerate with respect to the
        size of the input array, then use a blocked algorithm. (Default: 64)
    
    Returns
    -------
    sqrtm : (N, N) ndarray
        Value of the sqrt function at `A`
    
    errest : float
        (if disp == False)
    
        Frobenius norm of the estimated error, ||err||_F / ||A||_F
    
    References
    ----------
    .. [1] Edvin Deadman, Nicholas J. Higham, Rui Ralha (2013)
           ""Blocked Schur Algorithms for Computing the Matrix Square Root,
           Lecture Notes in Computer Science, 7782. pp. 171-182.
    
    Examples
    --------
    >>> from scipy.linalg import sqrtm
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> r = sqrtm(a)
    >>> r
    array([[ 0.75592895,  1.13389342],
           [ 0.37796447,  1.88982237]])
    >>> r.dot(r)
    array([[ 1.,  3.],
           [ 1.,  4.]])
",function,"('A', 'disp', 'blocksize')","(nan, True, 64)","(nan, 'bool', 'int')","('arg_info', 'arg_info', 'arg_info')","('(A, disp=True, blocksize=64)',)"
scipy,1.1.0,scipy.linalg._procrustes.orthogonal_procrustes,linalg._procrustes,orthogonal_procrustes,"Python Library Documentation: function orthogonal_procrustes in module scipy.linalg._procrustes

orthogonal_procrustes(A, B, check_finite=True)
    Compute the matrix solution of the orthogonal Procrustes problem.
    
    Given matrices A and B of equal shape, find an orthogonal matrix R
    that most closely maps A to B using the algorithm given in [1]_.
    
    Parameters
    ----------
    A : (M, N) array_like
        Matrix to be mapped.
    B : (M, N) array_like
        Target matrix.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    R : (N, N) ndarray
        The matrix solution of the orthogonal Procrustes problem.
        Minimizes the Frobenius norm of ``(A @ R) - B``, subject to
        ``R.T @ R = I``.
    scale : float
        Sum of the singular values of ``A.T @ B``.
    
    Raises
    ------
    ValueError
        If the input array shapes don't match or if check_finite is True and
        the arrays contain Inf or NaN.
    
    Notes
    -----
    Note that unlike higher level Procrustes analyses of spatial data, this
    function only uses orthogonal transformations like rotations and
    reflections, and it does not use scaling or translation.
    
    .. versionadded:: 0.15.0
    
    References
    ----------
    .. [1] Peter H. Schonemann, ""A generalized solution of the orthogonal
           Procrustes problem"", Psychometrica -- Vol. 31, No. 1, March, 1996.
    
    Examples
    --------
    >>> from scipy.linalg import orthogonal_procrustes
    >>> A = np.array([[ 2,  0,  1], [-2,  0,  0]])
    
    Flip the order of columns and check for the anti-diagonal mapping
    
    >>> R, sca = orthogonal_procrustes(A, np.fliplr(A))
    >>> R
    array([[-5.34384992e-17,  0.00000000e+00,  1.00000000e+00],
           [ 0.00000000e+00,  1.00000000e+00,  0.00000000e+00],
           [ 1.00000000e+00,  0.00000000e+00, -7.85941422e-17]])
    >>> sca
    9.0
",function,"('(A, B, check_finite=True)',)",scipy,1.1.0,scipy.linalg._procrustes.orthogonal_procrustes,linalg._procrustes,orthogonal_procrustes,"Python Library Documentation: function orthogonal_procrustes in module scipy.linalg._procrustes

orthogonal_procrustes(A, B, check_finite=True)
    Compute the matrix solution of the orthogonal Procrustes problem.
    
    Given matrices A and B of equal shape, find an orthogonal matrix R
    that most closely maps A to B using the algorithm given in [1]_.
    
    Parameters
    ----------
    A : (M, N) array_like
        Matrix to be mapped.
    B : (M, N) array_like
        Target matrix.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    R : (N, N) ndarray
        The matrix solution of the orthogonal Procrustes problem.
        Minimizes the Frobenius norm of ``(A @ R) - B``, subject to
        ``R.T @ R = I``.
    scale : float
        Sum of the singular values of ``A.T @ B``.
    
    Raises
    ------
    ValueError
        If the input array shapes don't match or if check_finite is True and
        the arrays contain Inf or NaN.
    
    Notes
    -----
    Note that unlike higher level Procrustes analyses of spatial data, this
    function only uses orthogonal transformations like rotations and
    reflections, and it does not use scaling or translation.
    
    .. versionadded:: 0.15.0
    
    References
    ----------
    .. [1] Peter H. Schonemann, ""A generalized solution of the orthogonal
           Procrustes problem"", Psychometrica -- Vol. 31, No. 1, March, 1996.
    
    Examples
    --------
    >>> from scipy.linalg import orthogonal_procrustes
    >>> A = np.array([[ 2,  0,  1], [-2,  0,  0]])
    
    Flip the order of columns and check for the anti-diagonal mapping
    
    >>> R, sca = orthogonal_procrustes(A, np.fliplr(A))
    >>> R
    array([[-5.34384992e-17,  0.00000000e+00,  1.00000000e+00],
           [ 0.00000000e+00,  1.00000000e+00,  0.00000000e+00],
           [ 1.00000000e+00,  0.00000000e+00, -7.85941422e-17]])
    >>> sca
    9.0
",function,"('A', 'B', 'check_finite')","(nan, nan, True)","(nan, nan, 'bool')","('arg_info', 'arg_info', 'arg_info')","('(A, B, check_finite=True)',)"
scipy,1.1.0,scipy.linalg._procrustes.svd,linalg._procrustes,svd,"Python Library Documentation: function svd in module scipy.linalg.decomp_svd

svd(a, full_matrices=True, compute_uv=True, overwrite_a=False, check_finite=True, lapack_driver='gesdd')
    Singular Value Decomposition.
    
    Factorizes the matrix `a` into two unitary matrices ``U`` and ``Vh``, and
    a 1-D array ``s`` of singular values (real, non-negative) such that
    ``a == U @ S @ Vh``, where ``S`` is a suitably shaped matrix of zeros with
    main diagonal ``s``.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to decompose.
    full_matrices : bool, optional
        If True (default), `U` and `Vh` are of shape ``(M, M)``, ``(N, N)``.
        If False, the shapes are ``(M, K)`` and ``(K, N)``, where
        ``K = min(M, N)``.
    compute_uv : bool, optional
        Whether to compute also ``U`` and ``Vh`` in addition to ``s``.
        Default is True.
    overwrite_a : bool, optional
        Whether to overwrite `a`; may improve performance.
        Default is False.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    lapack_driver : {'gesdd', 'gesvd'}, optional
        Whether to use the more efficient divide-and-conquer approach
        (``'gesdd'``) or general rectangular approach (``'gesvd'``)
        to compute the SVD. MATLAB and Octave use the ``'gesvd'`` approach.
        Default is ``'gesdd'``.
    
        .. versionadded:: 0.18
    
    Returns
    -------
    U : ndarray
        Unitary matrix having left singular vectors as columns.
        Of shape ``(M, M)`` or ``(M, K)``, depending on `full_matrices`.
    s : ndarray
        The singular values, sorted in non-increasing order.
        Of shape (K,), with ``K = min(M, N)``.
    Vh : ndarray
        Unitary matrix having right singular vectors as rows.
        Of shape ``(N, N)`` or ``(K, N)`` depending on `full_matrices`.
    
    For ``compute_uv=False``, only ``s`` is returned.
    
    Raises
    ------
    LinAlgError
        If SVD computation does not converge.
    
    See also
    --------
    svdvals : Compute singular values of a matrix.
    diagsvd : Construct the Sigma matrix, given the vector s.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> m, n = 9, 6
    >>> a = np.random.randn(m, n) + 1.j*np.random.randn(m, n)
    >>> U, s, Vh = linalg.svd(a)
    >>> U.shape,  s.shape, Vh.shape
    ((9, 9), (6,), (6, 6))
    
    Reconstruct the original matrix from the decomposition:
    
    >>> sigma = np.zeros((m, n))
    >>> for i in range(min(m, n)):
    ...     sigma[i, i] = s[i]
    >>> a1 = np.dot(U, np.dot(sigma, Vh))
    >>> np.allclose(a, a1)
    True
    
    Alternatively, use ``full_matrices=False`` (notice that the shape of
    ``U`` is then ``(m, n)`` instead of ``(m, m)``):
    
    >>> U, s, Vh = linalg.svd(a, full_matrices=False)
    >>> U.shape, s.shape, Vh.shape
    ((9, 6), (6,), (6, 6))
    >>> S = np.diag(s)
    >>> np.allclose(a, np.dot(U, np.dot(S, Vh)))
    True
    
    >>> s2 = linalg.svd(a, compute_uv=False)
    >>> np.allclose(s, s2)
    True
",function,"(""(a, full_matrices=True, compute_uv=True, overwrite_a=False, check_finite=True, lapack_driver='gesdd')"",)",scipy,1.1.0,scipy.linalg._procrustes.svd,linalg._procrustes,svd,"Python Library Documentation: function svd in module scipy.linalg.decomp_svd

svd(a, full_matrices=True, compute_uv=True, overwrite_a=False, check_finite=True, lapack_driver='gesdd')
    Singular Value Decomposition.
    
    Factorizes the matrix `a` into two unitary matrices ``U`` and ``Vh``, and
    a 1-D array ``s`` of singular values (real, non-negative) such that
    ``a == U @ S @ Vh``, where ``S`` is a suitably shaped matrix of zeros with
    main diagonal ``s``.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to decompose.
    full_matrices : bool, optional
        If True (default), `U` and `Vh` are of shape ``(M, M)``, ``(N, N)``.
        If False, the shapes are ``(M, K)`` and ``(K, N)``, where
        ``K = min(M, N)``.
    compute_uv : bool, optional
        Whether to compute also ``U`` and ``Vh`` in addition to ``s``.
        Default is True.
    overwrite_a : bool, optional
        Whether to overwrite `a`; may improve performance.
        Default is False.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    lapack_driver : {'gesdd', 'gesvd'}, optional
        Whether to use the more efficient divide-and-conquer approach
        (``'gesdd'``) or general rectangular approach (``'gesvd'``)
        to compute the SVD. MATLAB and Octave use the ``'gesvd'`` approach.
        Default is ``'gesdd'``.
    
        .. versionadded:: 0.18
    
    Returns
    -------
    U : ndarray
        Unitary matrix having left singular vectors as columns.
        Of shape ``(M, M)`` or ``(M, K)``, depending on `full_matrices`.
    s : ndarray
        The singular values, sorted in non-increasing order.
        Of shape (K,), with ``K = min(M, N)``.
    Vh : ndarray
        Unitary matrix having right singular vectors as rows.
        Of shape ``(N, N)`` or ``(K, N)`` depending on `full_matrices`.
    
    For ``compute_uv=False``, only ``s`` is returned.
    
    Raises
    ------
    LinAlgError
        If SVD computation does not converge.
    
    See also
    --------
    svdvals : Compute singular values of a matrix.
    diagsvd : Construct the Sigma matrix, given the vector s.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> m, n = 9, 6
    >>> a = np.random.randn(m, n) + 1.j*np.random.randn(m, n)
    >>> U, s, Vh = linalg.svd(a)
    >>> U.shape,  s.shape, Vh.shape
    ((9, 9), (6,), (6, 6))
    
    Reconstruct the original matrix from the decomposition:
    
    >>> sigma = np.zeros((m, n))
    >>> for i in range(min(m, n)):
    ...     sigma[i, i] = s[i]
    >>> a1 = np.dot(U, np.dot(sigma, Vh))
    >>> np.allclose(a, a1)
    True
    
    Alternatively, use ``full_matrices=False`` (notice that the shape of
    ``U`` is then ``(m, n)`` instead of ``(m, m)``):
    
    >>> U, s, Vh = linalg.svd(a, full_matrices=False)
    >>> U.shape, s.shape, Vh.shape
    ((9, 6), (6,), (6, 6))
    >>> S = np.diag(s)
    >>> np.allclose(a, np.dot(U, np.dot(S, Vh)))
    True
    
    >>> s2 = linalg.svd(a, compute_uv=False)
    >>> np.allclose(s, s2)
    True
",function,"('a', 'full_matrices', 'compute_uv', 'overwrite_a', 'check_finite', 'lapack_driver')","(nan, True, True, False, True, 'gesdd')","(nan, 'bool', 'bool', 'bool', 'bool', 'str')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a, full_matrices=True, compute_uv=True, overwrite_a=False, check_finite=True, lapack_driver='gesdd')"",)"
scipy,1.1.0,scipy.linalg._sketches.check_random_state,linalg._sketches,check_random_state,"Python Library Documentation: function check_random_state in module scipy._lib._util

check_random_state(seed)
    Turn seed into a np.random.RandomState instance
    
    If seed is None (or np.random), return the RandomState singleton used
    by np.random.
    If seed is an int, return a new RandomState instance seeded with seed.
    If seed is already a RandomState instance, return it.
    Otherwise raise ValueError.
",function,"('(seed)',)",scipy,1.1.0,scipy.linalg._sketches.check_random_state,linalg._sketches,check_random_state,"Python Library Documentation: function check_random_state in module scipy._lib._util

check_random_state(seed)
    Turn seed into a np.random.RandomState instance
    
    If seed is None (or np.random), return the RandomState singleton used
    by np.random.
    If seed is an int, return a new RandomState instance seeded with seed.
    If seed is already a RandomState instance, return it.
    Otherwise raise ValueError.
",function,"('seed',)","(nan,)","(nan,)","('arg_info',)","('(seed)',)"
scipy,1.1.0,scipy.linalg._sketches.clarkson_woodruff_transform,linalg._sketches,clarkson_woodruff_transform,"Python Library Documentation: function clarkson_woodruff_transform in module scipy.linalg._sketches

clarkson_woodruff_transform(input_matrix, sketch_size, seed=None)
    ""
    Find low-rank matrix approximation via the Clarkson-Woodruff Transform.
    
    Given an input_matrix ``A`` of size ``(n, d)``, compute a matrix ``A'`` of
    size (sketch_size, d) which holds:
    
    .. math:: ||Ax|| = (1 \pm \epsilon)||A'x||
    
    with high probability.
    
    The error is related to the number of rows of the sketch and it is bounded
    
    .. math:: poly(r(\epsilon^{-1}))
    
    Parameters
    ----------
    input_matrix: array_like
        Input matrix, of shape ``(n, d)``.
    sketch_size: int
        Number of rows for the sketch.
    seed : None or int or `numpy.random.RandomState` instance, optional
        This parameter defines the ``RandomState`` object to use for drawing
        random variates.
        If None (or ``np.random``), the global ``np.random`` state is used.
        If integer, it is used to seed the local ``RandomState`` instance.
        Default is None.
    
    Returns
    -------
    A' : array_like
        Sketch of the input matrix ``A``, of size ``(sketch_size, d)``.
    
    Notes
    -----
    This is an implementation of the Clarkson-Woodruff Transform (CountSketch).
    ``A'`` can be computed in principle in ``O(nnz(A))`` (with ``nnz`` meaning
    the number of nonzero entries), however we don't take advantage of sparse
    matrices in this implementation.
    
    Examples
    --------
    Given a big dense matrix ``A``:
    
    >>> from scipy import linalg
    >>> n_rows, n_columns, sketch_n_rows = (2000, 100, 100)
    >>> threshold = 0.1
    >>> tmp = np.random.normal(0, 0.1, n_rows*n_columns)
    >>> A = np.reshape(tmp, (n_rows, n_columns))
    >>> sketch = linalg.clarkson_woodruff_transform(A, sketch_n_rows)
    >>> sketch.shape
    (100, 100)
    >>> normA = linalg.norm(A)
    >>> norm_sketch = linalg.norm(sketch)
    
    Now with high probability, the condition ``abs(normA-normSketch) <
    threshold`` holds.
    
    References
    ----------
    .. [1] Kenneth L. Clarkson and David P. Woodruff. Low rank approximation and
           regression in input sparsity time. In STOC, 2013.
",function,"('(input_matrix, sketch_size, seed=None)',)",scipy,1.1.0,scipy.linalg._sketches.clarkson_woodruff_transform,linalg._sketches,clarkson_woodruff_transform,"Python Library Documentation: function clarkson_woodruff_transform in module scipy.linalg._sketches

clarkson_woodruff_transform(input_matrix, sketch_size, seed=None)
    ""
    Find low-rank matrix approximation via the Clarkson-Woodruff Transform.
    
    Given an input_matrix ``A`` of size ``(n, d)``, compute a matrix ``A'`` of
    size (sketch_size, d) which holds:
    
    .. math:: ||Ax|| = (1 \pm \epsilon)||A'x||
    
    with high probability.
    
    The error is related to the number of rows of the sketch and it is bounded
    
    .. math:: poly(r(\epsilon^{-1}))
    
    Parameters
    ----------
    input_matrix: array_like
        Input matrix, of shape ``(n, d)``.
    sketch_size: int
        Number of rows for the sketch.
    seed : None or int or `numpy.random.RandomState` instance, optional
        This parameter defines the ``RandomState`` object to use for drawing
        random variates.
        If None (or ``np.random``), the global ``np.random`` state is used.
        If integer, it is used to seed the local ``RandomState`` instance.
        Default is None.
    
    Returns
    -------
    A' : array_like
        Sketch of the input matrix ``A``, of size ``(sketch_size, d)``.
    
    Notes
    -----
    This is an implementation of the Clarkson-Woodruff Transform (CountSketch).
    ``A'`` can be computed in principle in ``O(nnz(A))`` (with ``nnz`` meaning
    the number of nonzero entries), however we don't take advantage of sparse
    matrices in this implementation.
    
    Examples
    --------
    Given a big dense matrix ``A``:
    
    >>> from scipy import linalg
    >>> n_rows, n_columns, sketch_n_rows = (2000, 100, 100)
    >>> threshold = 0.1
    >>> tmp = np.random.normal(0, 0.1, n_rows*n_columns)
    >>> A = np.reshape(tmp, (n_rows, n_columns))
    >>> sketch = linalg.clarkson_woodruff_transform(A, sketch_n_rows)
    >>> sketch.shape
    (100, 100)
    >>> normA = linalg.norm(A)
    >>> norm_sketch = linalg.norm(sketch)
    
    Now with high probability, the condition ``abs(normA-normSketch) <
    threshold`` holds.
    
    References
    ----------
    .. [1] Kenneth L. Clarkson and David P. Woodruff. Low rank approximation and
           regression in input sparsity time. In STOC, 2013.
",function,"('input_matrix', 'sketch_size', 'seed')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(input_matrix, sketch_size, seed=None)',)"
scipy,1.1.0,scipy.linalg._sketches.cwt_matrix,linalg._sketches,cwt_matrix,"Python Library Documentation: function cwt_matrix in module scipy.linalg._sketches

cwt_matrix(n_rows, n_columns, seed=None)
    ""
    Generate a matrix S for the Clarkson-Woodruff sketch.
    
    Given the desired size of matrix, the method returns a matrix S of size
    (n_rows, n_columns) where each column has all the entries set to 0 less one
    position which has been randomly set to +1 or -1 with equal probability.
    
    Parameters
    ----------
    n_rows: int
        Number of rows of S
    n_columns: int
        Number of columns of S
    seed : None or int or `numpy.random.RandomState` instance, optional
        This parameter defines the ``RandomState`` object to use for drawing
        random variates.
        If None (or ``np.random``), the global ``np.random`` state is used.
        If integer, it is used to seed the local ``RandomState`` instance.
        Default is None.
    
    Returns
    -------
    S : (n_rows, n_columns) array_like
    
    Notes
    -----
    Given a matrix A, with probability at least 9/10,
    .. math:: ||SA|| == (1 \pm \epsilon)||A||
    Where epsilon is related to the size of S
",function,"('(n_rows, n_columns, seed=None)',)",scipy,1.1.0,scipy.linalg._sketches.cwt_matrix,linalg._sketches,cwt_matrix,"Python Library Documentation: function cwt_matrix in module scipy.linalg._sketches

cwt_matrix(n_rows, n_columns, seed=None)
    ""
    Generate a matrix S for the Clarkson-Woodruff sketch.
    
    Given the desired size of matrix, the method returns a matrix S of size
    (n_rows, n_columns) where each column has all the entries set to 0 less one
    position which has been randomly set to +1 or -1 with equal probability.
    
    Parameters
    ----------
    n_rows: int
        Number of rows of S
    n_columns: int
        Number of columns of S
    seed : None or int or `numpy.random.RandomState` instance, optional
        This parameter defines the ``RandomState`` object to use for drawing
        random variates.
        If None (or ``np.random``), the global ``np.random`` state is used.
        If integer, it is used to seed the local ``RandomState`` instance.
        Default is None.
    
    Returns
    -------
    S : (n_rows, n_columns) array_like
    
    Notes
    -----
    Given a matrix A, with probability at least 9/10,
    .. math:: ||SA|| == (1 \pm \epsilon)||A||
    Where epsilon is related to the size of S
",function,"('n_rows', 'n_columns', 'seed')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(n_rows, n_columns, seed=None)',)"
scipy,1.1.0,scipy.linalg._solve_toeplitz.LinAlgError,linalg._solve_toeplitz,LinAlgError,"Python Library Documentation: class LinAlgError in module numpy.linalg.linalg

class LinAlgError(builtins.Exception)
 |  Generic Python-exception-derived object raised by linalg functions.
 |  
 |  General purpose exception class, derived from Python's exception.Exception
 |  class, programmatically raised in linalg functions when a Linear
 |  Algebra-related condition would prevent further correct execution of the
 |  function.
 |  
 |  Parameters
 |  ----------
 |  None
 |  
 |  Examples
 |  --------
 |  >>> from numpy import linalg as LA
 |  >>> LA.inv(np.zeros((2,2)))
 |  Traceback (most recent call last):
 |    File ""<stdin>"", line 1, in <module>
 |    File ""...linalg.py"", line 350,
 |      in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
 |    File ""...linalg.py"", line 249,
 |      in solve
 |      raise LinAlgError('Singular matrix')
 |  numpy.linalg.LinAlgError: Singular matrix
 |  
 |  Method resolution order:
 |      LinAlgError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg._solve_toeplitz.LinAlgError,linalg._solve_toeplitz,LinAlgError,"Python Library Documentation: class LinAlgError in module numpy.linalg.linalg

class LinAlgError(builtins.Exception)
 |  Generic Python-exception-derived object raised by linalg functions.
 |  
 |  General purpose exception class, derived from Python's exception.Exception
 |  class, programmatically raised in linalg functions when a Linear
 |  Algebra-related condition would prevent further correct execution of the
 |  function.
 |  
 |  Parameters
 |  ----------
 |  None
 |  
 |  Examples
 |  --------
 |  >>> from numpy import linalg as LA
 |  >>> LA.inv(np.zeros((2,2)))
 |  Traceback (most recent call last):
 |    File ""<stdin>"", line 1, in <module>
 |    File ""...linalg.py"", line 350,
 |      in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
 |    File ""...linalg.py"", line 249,
 |      in solve
 |      raise LinAlgError('Singular matrix')
 |  numpy.linalg.LinAlgError: Singular matrix
 |  
 |  Method resolution order:
 |      LinAlgError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg._solve_toeplitz.asarray,linalg._solve_toeplitz,asarray,"Python Library Documentation: function asarray in module numpy.core.numeric

asarray(a, dtype=None, order=None)
    Convert the input to an array.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
        Whether to use row-major (C-style) or
        column-major (Fortran-style) memory representation.
        Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray with matching dtype and order.  If `a` is a
        subclass of ndarray, a base class ndarray is returned.
    
    See Also
    --------
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    asarray_chkfinite : Similar function which checks input for NaNs and Infs.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array:
    
    >>> a = [1, 2]
    >>> np.asarray(a)
    array([1, 2])
    
    Existing arrays are not copied:
    
    >>> a = np.array([1, 2])
    >>> np.asarray(a) is a
    True
    
    If `dtype` is set, array is copied only if dtype does not match:
    
    >>> a = np.array([1, 2], dtype=np.float32)
    >>> np.asarray(a, dtype=np.float32) is a
    True
    >>> np.asarray(a, dtype=np.float64) is a
    False
    
    Contrary to `asanyarray`, ndarray subclasses are not passed through:
    
    >>> issubclass(np.matrix, np.ndarray)
    True
    >>> a = np.matrix([[1, 2]])
    >>> np.asarray(a) is a
    False
    >>> np.asanyarray(a) is a
    True
",function,"('(a, dtype=None, order=None)',)",scipy,1.1.0,scipy.linalg._solve_toeplitz.asarray,linalg._solve_toeplitz,asarray,"Python Library Documentation: function asarray in module numpy.core.numeric

asarray(a, dtype=None, order=None)
    Convert the input to an array.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
        Whether to use row-major (C-style) or
        column-major (Fortran-style) memory representation.
        Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray with matching dtype and order.  If `a` is a
        subclass of ndarray, a base class ndarray is returned.
    
    See Also
    --------
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    asarray_chkfinite : Similar function which checks input for NaNs and Infs.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array:
    
    >>> a = [1, 2]
    >>> np.asarray(a)
    array([1, 2])
    
    Existing arrays are not copied:
    
    >>> a = np.array([1, 2])
    >>> np.asarray(a) is a
    True
    
    If `dtype` is set, array is copied only if dtype does not match:
    
    >>> a = np.array([1, 2], dtype=np.float32)
    >>> np.asarray(a, dtype=np.float32) is a
    True
    >>> np.asarray(a, dtype=np.float64) is a
    False
    
    Contrary to `asanyarray`, ndarray subclasses are not passed through:
    
    >>> issubclass(np.matrix, np.ndarray)
    True
    >>> a = np.matrix([[1, 2]])
    >>> np.asarray(a) is a
    False
    >>> np.asanyarray(a) is a
    True
",function,"('a', 'dtype', 'order')","(nan, None, None)","(nan, 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(a, dtype=None, order=None)',)"
scipy,1.1.0,scipy.linalg._solve_toeplitz.complex128,linalg._solve_toeplitz,complex128,"Python Library Documentation: class complex128 in module numpy

class complex128(complexfloating, builtins.complex)
 |  Composed of two 64 bit floats
 |  
 |  Method resolution order:
 |      complex128
 |      complexfloating
 |      inexact
 |      number
 |      generic
 |      builtins.complex
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from generic:
 |  
 |  __array__(...)
 |      sc.__array__(|type) return 0-dim array
 |  
 |  __array_wrap__(...)
 |      sc.__array_wrap__(obj) return scalar from array
 |  
 |  __copy__(...)
 |  
 |  __deepcopy__(...)
 |  
 |  __format__(...)
 |      NumPy array scalar formatter
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __round__(...)
 |  
 |  __setstate__(...)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  all(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  any(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmax(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmin(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argsort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  astype(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  byteswap(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  choose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  clip(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  compress(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  conj(...)
 |  
 |  conjugate(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  copy(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumprod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumsum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  diagonal(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dump(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dumps(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  fill(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  flatten(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  getfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  item(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  itemset(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  max(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  mean(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  min(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  newbyteorder(...)
 |      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.
 |      
 |      The `new_order` code can be any from the following:
 |      
 |      * 'S' - swap dtype from current to opposite endian
 |      * {'<', 'L'} - little endian
 |      * {'>', 'B'} - big endian
 |      * {'=', 'N'} - native order
 |      * {'|', 'I'} - ignore (no change to byte order)
 |      
 |      Parameters
 |      ----------
 |      new_order : str, optional
 |          Byte order to force; a value from the byte order specifications
 |          above.  The default value ('S') results in swapping the current
 |          byte order. The code does a case-insensitive check on the first
 |          letter of `new_order` for the alternatives above.  For example,
 |          any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 |      
 |      
 |      Returns
 |      -------
 |      new_dtype : dtype
 |          New `dtype` object with the given change to the byte order.
 |  
 |  nonzero(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  prod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ptp(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  put(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ravel(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  repeat(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  reshape(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  resize(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  round(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  searchsorted(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setflags(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  squeeze(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  std(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  swapaxes(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  take(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tobytes(...)
 |  
 |  tofile(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tolist(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tostring(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  trace(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  transpose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  var(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  view(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from generic:
 |  
 |  T
 |      transpose
 |  
 |  __array_interface__
 |      Array protocol: Python side
 |  
 |  __array_priority__
 |      Array priority.
 |  
 |  __array_struct__
 |      Array protocol: struct
 |  
 |  base
 |      base object
 |  
 |  data
 |      pointer to start of data
 |  
 |  dtype
 |      get array data-descriptor
 |  
 |  flags
 |      integer value of flags
 |  
 |  flat
 |      a 1-d view of scalar
 |  
 |  imag
 |      imaginary part of scalar
 |  
 |  itemsize
 |      length of one element in bytes
 |  
 |  nbytes
 |      length of item in bytes
 |  
 |  ndim
 |      number of array dimensions
 |  
 |  real
 |      real part of scalar
 |  
 |  shape
 |      tuple of array dimensions
 |  
 |  size
 |      number of elements in the gentype
 |  
 |  strides
 |      tuple of bytes steps in each dimension
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.complex:
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getnewargs__(...)
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg._solve_toeplitz.complex128,linalg._solve_toeplitz,complex128,"Python Library Documentation: class complex128 in module numpy

class complex128(complexfloating, builtins.complex)
 |  Composed of two 64 bit floats
 |  
 |  Method resolution order:
 |      complex128
 |      complexfloating
 |      inexact
 |      number
 |      generic
 |      builtins.complex
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from generic:
 |  
 |  __array__(...)
 |      sc.__array__(|type) return 0-dim array
 |  
 |  __array_wrap__(...)
 |      sc.__array_wrap__(obj) return scalar from array
 |  
 |  __copy__(...)
 |  
 |  __deepcopy__(...)
 |  
 |  __format__(...)
 |      NumPy array scalar formatter
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __round__(...)
 |  
 |  __setstate__(...)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  all(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  any(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmax(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmin(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argsort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  astype(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  byteswap(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  choose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  clip(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  compress(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  conj(...)
 |  
 |  conjugate(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  copy(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumprod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumsum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  diagonal(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dump(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dumps(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  fill(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  flatten(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  getfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  item(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  itemset(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  max(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  mean(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  min(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  newbyteorder(...)
 |      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.
 |      
 |      The `new_order` code can be any from the following:
 |      
 |      * 'S' - swap dtype from current to opposite endian
 |      * {'<', 'L'} - little endian
 |      * {'>', 'B'} - big endian
 |      * {'=', 'N'} - native order
 |      * {'|', 'I'} - ignore (no change to byte order)
 |      
 |      Parameters
 |      ----------
 |      new_order : str, optional
 |          Byte order to force; a value from the byte order specifications
 |          above.  The default value ('S') results in swapping the current
 |          byte order. The code does a case-insensitive check on the first
 |          letter of `new_order` for the alternatives above.  For example,
 |          any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 |      
 |      
 |      Returns
 |      -------
 |      new_dtype : dtype
 |          New `dtype` object with the given change to the byte order.
 |  
 |  nonzero(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  prod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ptp(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  put(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ravel(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  repeat(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  reshape(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  resize(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  round(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  searchsorted(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setflags(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  squeeze(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  std(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  swapaxes(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  take(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tobytes(...)
 |  
 |  tofile(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tolist(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tostring(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  trace(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  transpose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  var(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  view(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from generic:
 |  
 |  T
 |      transpose
 |  
 |  __array_interface__
 |      Array protocol: Python side
 |  
 |  __array_priority__
 |      Array priority.
 |  
 |  __array_struct__
 |      Array protocol: struct
 |  
 |  base
 |      base object
 |  
 |  data
 |      pointer to start of data
 |  
 |  dtype
 |      get array data-descriptor
 |  
 |  flags
 |      integer value of flags
 |  
 |  flat
 |      a 1-d view of scalar
 |  
 |  imag
 |      imaginary part of scalar
 |  
 |  itemsize
 |      length of one element in bytes
 |  
 |  nbytes
 |      length of item in bytes
 |  
 |  ndim
 |      number of array dimensions
 |  
 |  real
 |      real part of scalar
 |  
 |  shape
 |      tuple of array dimensions
 |  
 |  size
 |      number of elements in the gentype
 |  
 |  strides
 |      tuple of bytes steps in each dimension
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.complex:
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getnewargs__(...)
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg._solve_toeplitz.float64,linalg._solve_toeplitz,float64,"Python Library Documentation: class float64 in module numpy

class float64(floating, builtins.float)
 |  64-bit floating-point number. Character code 'd'. Python float compatible.
 |  
 |  Method resolution order:
 |      float64
 |      floating
 |      inexact
 |      number
 |      generic
 |      builtins.float
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from generic:
 |  
 |  __array__(...)
 |      sc.__array__(|type) return 0-dim array
 |  
 |  __array_wrap__(...)
 |      sc.__array_wrap__(obj) return scalar from array
 |  
 |  __copy__(...)
 |  
 |  __deepcopy__(...)
 |  
 |  __format__(...)
 |      NumPy array scalar formatter
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __round__(...)
 |  
 |  __setstate__(...)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  all(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  any(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmax(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmin(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argsort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  astype(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  byteswap(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  choose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  clip(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  compress(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  conj(...)
 |  
 |  conjugate(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  copy(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumprod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumsum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  diagonal(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dump(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dumps(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  fill(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  flatten(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  getfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  item(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  itemset(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  max(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  mean(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  min(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  newbyteorder(...)
 |      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.
 |      
 |      The `new_order` code can be any from the following:
 |      
 |      * 'S' - swap dtype from current to opposite endian
 |      * {'<', 'L'} - little endian
 |      * {'>', 'B'} - big endian
 |      * {'=', 'N'} - native order
 |      * {'|', 'I'} - ignore (no change to byte order)
 |      
 |      Parameters
 |      ----------
 |      new_order : str, optional
 |          Byte order to force; a value from the byte order specifications
 |          above.  The default value ('S') results in swapping the current
 |          byte order. The code does a case-insensitive check on the first
 |          letter of `new_order` for the alternatives above.  For example,
 |          any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 |      
 |      
 |      Returns
 |      -------
 |      new_dtype : dtype
 |          New `dtype` object with the given change to the byte order.
 |  
 |  nonzero(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  prod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ptp(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  put(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ravel(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  repeat(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  reshape(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  resize(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  round(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  searchsorted(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setflags(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  squeeze(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  std(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  swapaxes(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  take(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tobytes(...)
 |  
 |  tofile(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tolist(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tostring(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  trace(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  transpose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  var(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  view(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from generic:
 |  
 |  T
 |      transpose
 |  
 |  __array_interface__
 |      Array protocol: Python side
 |  
 |  __array_priority__
 |      Array priority.
 |  
 |  __array_struct__
 |      Array protocol: struct
 |  
 |  base
 |      base object
 |  
 |  data
 |      pointer to start of data
 |  
 |  dtype
 |      get array data-descriptor
 |  
 |  flags
 |      integer value of flags
 |  
 |  flat
 |      a 1-d view of scalar
 |  
 |  imag
 |      imaginary part of scalar
 |  
 |  itemsize
 |      length of one element in bytes
 |  
 |  nbytes
 |      length of item in bytes
 |  
 |  ndim
 |      number of array dimensions
 |  
 |  real
 |      real part of scalar
 |  
 |  shape
 |      tuple of array dimensions
 |  
 |  size
 |      number of elements in the gentype
 |  
 |  strides
 |      tuple of bytes steps in each dimension
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.float:
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getformat__(...) from builtins.type
 |      float.__getformat__(typestr) -> string
 |      
 |      You probably don't want to use this function.  It exists mainly to be
 |      used in Python's test suite.
 |      
 |      typestr must be 'double' or 'float'.  This function returns whichever of
 |      'unknown', 'IEEE, big-endian' or 'IEEE, little-endian' best describes the
 |      format of floating point numbers used by the C type named by typestr.
 |  
 |  __getnewargs__(...)
 |  
 |  __setformat__(...) from builtins.type
 |      float.__setformat__(typestr, fmt) -> None
 |      
 |      You probably don't want to use this function.  It exists mainly to be
 |      used in Python's test suite.
 |      
 |      typestr must be 'double' or 'float'.  fmt must be one of 'unknown',
 |      'IEEE, big-endian' or 'IEEE, little-endian', and in addition can only be
 |      one of the latter two if it appears to match the underlying C reality.
 |      
 |      Override the automatic determination of C-level floating point type.
 |      This affects how floats are converted to and from binary strings.
 |  
 |  __trunc__(...)
 |      Return the Integral closest to x between 0 and x.
 |  
 |  as_integer_ratio(...)
 |      float.as_integer_ratio() -> (int, int)
 |      
 |      Return a pair of integers, whose ratio is exactly equal to the original
 |      float and with a positive denominator.
 |      Raise OverflowError on infinities and a ValueError on NaNs.
 |      
 |      >>> (10.0).as_integer_ratio()
 |      (10, 1)
 |      >>> (0.0).as_integer_ratio()
 |      (0, 1)
 |      >>> (-.25).as_integer_ratio()
 |      (-1, 4)
 |  
 |  fromhex(...) from builtins.type
 |      float.fromhex(string) -> float
 |      
 |      Create a floating-point number from a hexadecimal string.
 |      >>> float.fromhex('0x1.ffffp10')
 |      2047.984375
 |      >>> float.fromhex('-0x1p-1074')
 |      -5e-324
 |  
 |  hex(...)
 |      float.hex() -> string
 |      
 |      Return a hexadecimal representation of a floating-point number.
 |      >>> (-0.1).hex()
 |      '-0x1.999999999999ap-4'
 |      >>> 3.14159.hex()
 |      '0x1.921f9f01b866ep+1'
 |  
 |  is_integer(...)
 |      Return True if the float is an integer.
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg._solve_toeplitz.float64,linalg._solve_toeplitz,float64,"Python Library Documentation: class float64 in module numpy

class float64(floating, builtins.float)
 |  64-bit floating-point number. Character code 'd'. Python float compatible.
 |  
 |  Method resolution order:
 |      float64
 |      floating
 |      inexact
 |      number
 |      generic
 |      builtins.float
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from generic:
 |  
 |  __array__(...)
 |      sc.__array__(|type) return 0-dim array
 |  
 |  __array_wrap__(...)
 |      sc.__array_wrap__(obj) return scalar from array
 |  
 |  __copy__(...)
 |  
 |  __deepcopy__(...)
 |  
 |  __format__(...)
 |      NumPy array scalar formatter
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __round__(...)
 |  
 |  __setstate__(...)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  all(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  any(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmax(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmin(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argsort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  astype(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  byteswap(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  choose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  clip(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  compress(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  conj(...)
 |  
 |  conjugate(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  copy(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumprod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumsum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  diagonal(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dump(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dumps(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  fill(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  flatten(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  getfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  item(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  itemset(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  max(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  mean(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  min(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  newbyteorder(...)
 |      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.
 |      
 |      The `new_order` code can be any from the following:
 |      
 |      * 'S' - swap dtype from current to opposite endian
 |      * {'<', 'L'} - little endian
 |      * {'>', 'B'} - big endian
 |      * {'=', 'N'} - native order
 |      * {'|', 'I'} - ignore (no change to byte order)
 |      
 |      Parameters
 |      ----------
 |      new_order : str, optional
 |          Byte order to force; a value from the byte order specifications
 |          above.  The default value ('S') results in swapping the current
 |          byte order. The code does a case-insensitive check on the first
 |          letter of `new_order` for the alternatives above.  For example,
 |          any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 |      
 |      
 |      Returns
 |      -------
 |      new_dtype : dtype
 |          New `dtype` object with the given change to the byte order.
 |  
 |  nonzero(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  prod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ptp(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  put(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ravel(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  repeat(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  reshape(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  resize(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  round(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  searchsorted(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setflags(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  squeeze(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  std(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  swapaxes(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  take(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tobytes(...)
 |  
 |  tofile(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tolist(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tostring(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  trace(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  transpose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  var(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  view(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from generic:
 |  
 |  T
 |      transpose
 |  
 |  __array_interface__
 |      Array protocol: Python side
 |  
 |  __array_priority__
 |      Array priority.
 |  
 |  __array_struct__
 |      Array protocol: struct
 |  
 |  base
 |      base object
 |  
 |  data
 |      pointer to start of data
 |  
 |  dtype
 |      get array data-descriptor
 |  
 |  flags
 |      integer value of flags
 |  
 |  flat
 |      a 1-d view of scalar
 |  
 |  imag
 |      imaginary part of scalar
 |  
 |  itemsize
 |      length of one element in bytes
 |  
 |  nbytes
 |      length of item in bytes
 |  
 |  ndim
 |      number of array dimensions
 |  
 |  real
 |      real part of scalar
 |  
 |  shape
 |      tuple of array dimensions
 |  
 |  size
 |      number of elements in the gentype
 |  
 |  strides
 |      tuple of bytes steps in each dimension
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.float:
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getformat__(...) from builtins.type
 |      float.__getformat__(typestr) -> string
 |      
 |      You probably don't want to use this function.  It exists mainly to be
 |      used in Python's test suite.
 |      
 |      typestr must be 'double' or 'float'.  This function returns whichever of
 |      'unknown', 'IEEE, big-endian' or 'IEEE, little-endian' best describes the
 |      format of floating point numbers used by the C type named by typestr.
 |  
 |  __getnewargs__(...)
 |  
 |  __setformat__(...) from builtins.type
 |      float.__setformat__(typestr, fmt) -> None
 |      
 |      You probably don't want to use this function.  It exists mainly to be
 |      used in Python's test suite.
 |      
 |      typestr must be 'double' or 'float'.  fmt must be one of 'unknown',
 |      'IEEE, big-endian' or 'IEEE, little-endian', and in addition can only be
 |      one of the latter two if it appears to match the underlying C reality.
 |      
 |      Override the automatic determination of C-level floating point type.
 |      This affects how floats are converted to and from binary strings.
 |  
 |  __trunc__(...)
 |      Return the Integral closest to x between 0 and x.
 |  
 |  as_integer_ratio(...)
 |      float.as_integer_ratio() -> (int, int)
 |      
 |      Return a pair of integers, whose ratio is exactly equal to the original
 |      float and with a positive denominator.
 |      Raise OverflowError on infinities and a ValueError on NaNs.
 |      
 |      >>> (10.0).as_integer_ratio()
 |      (10, 1)
 |      >>> (0.0).as_integer_ratio()
 |      (0, 1)
 |      >>> (-.25).as_integer_ratio()
 |      (-1, 4)
 |  
 |  fromhex(...) from builtins.type
 |      float.fromhex(string) -> float
 |      
 |      Create a floating-point number from a hexadecimal string.
 |      >>> float.fromhex('0x1.ffffp10')
 |      2047.984375
 |      >>> float.fromhex('-0x1p-1074')
 |      -5e-324
 |  
 |  hex(...)
 |      float.hex() -> string
 |      
 |      Return a hexadecimal representation of a floating-point number.
 |      >>> (-0.1).hex()
 |      '-0x1.999999999999ap-4'
 |      >>> 3.14159.hex()
 |      '0x1.921f9f01b866ep+1'
 |  
 |  is_integer(...)
 |      Return True if the float is an integer.
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg._solvers.LinAlgError,linalg._solvers,LinAlgError,"Python Library Documentation: class LinAlgError in module numpy.linalg.linalg

class LinAlgError(builtins.Exception)
 |  Generic Python-exception-derived object raised by linalg functions.
 |  
 |  General purpose exception class, derived from Python's exception.Exception
 |  class, programmatically raised in linalg functions when a Linear
 |  Algebra-related condition would prevent further correct execution of the
 |  function.
 |  
 |  Parameters
 |  ----------
 |  None
 |  
 |  Examples
 |  --------
 |  >>> from numpy import linalg as LA
 |  >>> LA.inv(np.zeros((2,2)))
 |  Traceback (most recent call last):
 |    File ""<stdin>"", line 1, in <module>
 |    File ""...linalg.py"", line 350,
 |      in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
 |    File ""...linalg.py"", line 249,
 |      in solve
 |      raise LinAlgError('Singular matrix')
 |  numpy.linalg.LinAlgError: Singular matrix
 |  
 |  Method resolution order:
 |      LinAlgError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg._solvers.LinAlgError,linalg._solvers,LinAlgError,"Python Library Documentation: class LinAlgError in module numpy.linalg.linalg

class LinAlgError(builtins.Exception)
 |  Generic Python-exception-derived object raised by linalg functions.
 |  
 |  General purpose exception class, derived from Python's exception.Exception
 |  class, programmatically raised in linalg functions when a Linear
 |  Algebra-related condition would prevent further correct execution of the
 |  function.
 |  
 |  Parameters
 |  ----------
 |  None
 |  
 |  Examples
 |  --------
 |  >>> from numpy import linalg as LA
 |  >>> LA.inv(np.zeros((2,2)))
 |  Traceback (most recent call last):
 |    File ""<stdin>"", line 1, in <module>
 |    File ""...linalg.py"", line 350,
 |      in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
 |    File ""...linalg.py"", line 249,
 |      in solve
 |      raise LinAlgError('Singular matrix')
 |  numpy.linalg.LinAlgError: Singular matrix
 |  
 |  Method resolution order:
 |      LinAlgError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg._solvers._are_validate_args,linalg._solvers,_are_validate_args,"Python Library Documentation: function _are_validate_args in module scipy.linalg._solvers

_are_validate_args(a, b, q, r, e, s, eq_type='care')
    A helper function to validate the arguments supplied to the
    Riccati equation solvers. Any discrepancy found in the input
    matrices leads to a ``ValueError`` exception.
    
    Essentially, it performs:
    
        - a check whether the input is free of NaN and Infs.
        - a pass for the data through ``numpy.atleast_2d()``
        - squareness check of the relevant arrays,
        - shape consistency check of the arrays,
        - singularity check of the relevant arrays,
        - symmetricity check of the relevant matrices,
        - a check whether the regular or the generalized version is asked.
    
    This function is used by ``solve_continuous_are`` and
    ``solve_discrete_are``.
    
    Parameters
    ----------
    a, b, q, r, e, s : array_like
        Input data
    eq_type : str
        Accepted arguments are 'care' and 'dare'.
    
    Returns
    -------
    a, b, q, r, e, s : ndarray
        Regularized input data
    m, n : int
        shape of the problem
    r_or_c : type
        Data type of the problem, returns float or complex
    gen_or_not : bool
        Type of the equation, True for generalized and False for regular ARE.
",function,"(""(a, b, q, r, e, s, eq_type='care')"",)",scipy,1.1.0,scipy.linalg._solvers._are_validate_args,linalg._solvers,_are_validate_args,"Python Library Documentation: function _are_validate_args in module scipy.linalg._solvers

_are_validate_args(a, b, q, r, e, s, eq_type='care')
    A helper function to validate the arguments supplied to the
    Riccati equation solvers. Any discrepancy found in the input
    matrices leads to a ``ValueError`` exception.
    
    Essentially, it performs:
    
        - a check whether the input is free of NaN and Infs.
        - a pass for the data through ``numpy.atleast_2d()``
        - squareness check of the relevant arrays,
        - shape consistency check of the arrays,
        - singularity check of the relevant arrays,
        - symmetricity check of the relevant matrices,
        - a check whether the regular or the generalized version is asked.
    
    This function is used by ``solve_continuous_are`` and
    ``solve_discrete_are``.
    
    Parameters
    ----------
    a, b, q, r, e, s : array_like
        Input data
    eq_type : str
        Accepted arguments are 'care' and 'dare'.
    
    Returns
    -------
    a, b, q, r, e, s : ndarray
        Regularized input data
    m, n : int
        shape of the problem
    r_or_c : type
        Data type of the problem, returns float or complex
    gen_or_not : bool
        Type of the equation, True for generalized and False for regular ARE.
",function,"('a', 'b', 'q', 'r', 'e', 's', 'eq_type')","(nan, nan, nan, nan, nan, nan, 'care')","(nan, nan, nan, nan, nan, nan, 'str')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a, b, q, r, e, s, eq_type='care')"",)"
scipy,1.1.0,scipy.linalg._solvers._asarray_validated,linalg._solvers,_asarray_validated,"Python Library Documentation: function _asarray_validated in module scipy._lib._util

_asarray_validated(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)
    Helper function for scipy argument validation.
    
    Many scipy linear algebra functions do support arbitrary array-like
    input arguments.  Examples of commonly unsupported inputs include
    matrices containing inf/nan, sparse matrix representations, and
    matrices with complicated elements.
    
    Parameters
    ----------
    a : array_like
        The array-like input.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default: True
    sparse_ok : bool, optional
        True if scipy sparse matrices are allowed.
    objects_ok : bool, optional
        True if arrays with dype('O') are allowed.
    mask_ok : bool, optional
        True if masked arrays are allowed.
    as_inexact : bool, optional
        True to convert the input array to a np.inexact dtype.
    
    Returns
    -------
    ret : ndarray
        The converted validated array.
",function,"('(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)',)",scipy,1.1.0,scipy.linalg._solvers._asarray_validated,linalg._solvers,_asarray_validated,"Python Library Documentation: function _asarray_validated in module scipy._lib._util

_asarray_validated(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)
    Helper function for scipy argument validation.
    
    Many scipy linear algebra functions do support arbitrary array-like
    input arguments.  Examples of commonly unsupported inputs include
    matrices containing inf/nan, sparse matrix representations, and
    matrices with complicated elements.
    
    Parameters
    ----------
    a : array_like
        The array-like input.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default: True
    sparse_ok : bool, optional
        True if scipy sparse matrices are allowed.
    objects_ok : bool, optional
        True if arrays with dype('O') are allowed.
    mask_ok : bool, optional
        True if masked arrays are allowed.
    as_inexact : bool, optional
        True to convert the input array to a np.inexact dtype.
    
    Returns
    -------
    ret : ndarray
        The converted validated array.
",function,"('a', 'check_finite', 'sparse_ok', 'objects_ok', 'mask_ok', 'as_inexact')","(nan, True, False, False, False, False)","(nan, 'bool', 'bool', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)',)"
scipy,1.1.0,scipy.linalg._solvers._solve_discrete_lyapunov_bilinear,linalg._solvers,_solve_discrete_lyapunov_bilinear,"Python Library Documentation: function _solve_discrete_lyapunov_bilinear in module scipy.linalg._solvers

_solve_discrete_lyapunov_bilinear(a, q)
    Solves the discrete Lyapunov equation using a bilinear transformation.
    
    This function is called by the `solve_discrete_lyapunov` function with
    `method=bilinear`. It is not supposed to be called directly.
",function,"('(a, q)',)",scipy,1.1.0,scipy.linalg._solvers._solve_discrete_lyapunov_bilinear,linalg._solvers,_solve_discrete_lyapunov_bilinear,"Python Library Documentation: function _solve_discrete_lyapunov_bilinear in module scipy.linalg._solvers

_solve_discrete_lyapunov_bilinear(a, q)
    Solves the discrete Lyapunov equation using a bilinear transformation.
    
    This function is called by the `solve_discrete_lyapunov` function with
    `method=bilinear`. It is not supposed to be called directly.
",function,"('a', 'q')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(a, q)',)"
scipy,1.1.0,scipy.linalg._solvers._solve_discrete_lyapunov_direct,linalg._solvers,_solve_discrete_lyapunov_direct,"Python Library Documentation: function _solve_discrete_lyapunov_direct in module scipy.linalg._solvers

_solve_discrete_lyapunov_direct(a, q)
    Solves the discrete Lyapunov equation directly.
    
    This function is called by the `solve_discrete_lyapunov` function with
    `method=direct`. It is not supposed to be called directly.
",function,"('(a, q)',)",scipy,1.1.0,scipy.linalg._solvers._solve_discrete_lyapunov_direct,linalg._solvers,_solve_discrete_lyapunov_direct,"Python Library Documentation: function _solve_discrete_lyapunov_direct in module scipy.linalg._solvers

_solve_discrete_lyapunov_direct(a, q)
    Solves the discrete Lyapunov equation directly.
    
    This function is called by the `solve_discrete_lyapunov` function with
    `method=direct`. It is not supposed to be called directly.
",function,"('a', 'q')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(a, q)',)"
scipy,1.1.0,scipy.linalg._solvers.block_diag,linalg._solvers,block_diag,"Python Library Documentation: function block_diag in module scipy.linalg.special_matrices

block_diag(*arrs)
    Create a block diagonal matrix from provided arrays.
    
    Given the inputs `A`, `B` and `C`, the output will have these
    arrays arranged on the diagonal::
    
        [[A, 0, 0],
         [0, B, 0],
         [0, 0, C]]
    
    Parameters
    ----------
    A, B, C, ... : array_like, up to 2-D
        Input arrays.  A 1-D array or array_like sequence of length `n` is
        treated as a 2-D array with shape ``(1,n)``.
    
    Returns
    -------
    D : ndarray
        Array with `A`, `B`, `C`, ... on the diagonal.  `D` has the
        same dtype as `A`.
    
    Notes
    -----
    If all the input arrays are square, the output is known as a
    block diagonal matrix.
    
    Empty sequences (i.e., array-likes of zero size) will not be ignored.
    Noteworthy, both [] and [[]] are treated as matrices with shape ``(1,0)``.
    
    Examples
    --------
    >>> from scipy.linalg import block_diag
    >>> A = [[1, 0],
    ...      [0, 1]]
    >>> B = [[3, 4, 5],
    ...      [6, 7, 8]]
    >>> C = [[7]]
    >>> P = np.zeros((2, 0), dtype='int32')
    >>> block_diag(A, B, C)
    array([[1, 0, 0, 0, 0, 0],
           [0, 1, 0, 0, 0, 0],
           [0, 0, 3, 4, 5, 0],
           [0, 0, 6, 7, 8, 0],
           [0, 0, 0, 0, 0, 7]])
    >>> block_diag(A, P, B, C)
    array([[1, 0, 0, 0, 0, 0],
           [0, 1, 0, 0, 0, 0],
           [0, 0, 0, 0, 0, 0],
           [0, 0, 0, 0, 0, 0],
           [0, 0, 3, 4, 5, 0],
           [0, 0, 6, 7, 8, 0],
           [0, 0, 0, 0, 0, 7]])
    >>> block_diag(1.0, [2, 3], [[4, 5], [6, 7]])
    array([[ 1.,  0.,  0.,  0.,  0.],
           [ 0.,  2.,  3.,  0.,  0.],
           [ 0.,  0.,  0.,  4.,  5.],
           [ 0.,  0.,  0.,  6.,  7.]])
",function,"('(*arrs)',)",scipy,1.1.0,scipy.linalg._solvers.block_diag,linalg._solvers,block_diag,"Python Library Documentation: function block_diag in module scipy.linalg.special_matrices

block_diag(*arrs)
    Create a block diagonal matrix from provided arrays.
    
    Given the inputs `A`, `B` and `C`, the output will have these
    arrays arranged on the diagonal::
    
        [[A, 0, 0],
         [0, B, 0],
         [0, 0, C]]
    
    Parameters
    ----------
    A, B, C, ... : array_like, up to 2-D
        Input arrays.  A 1-D array or array_like sequence of length `n` is
        treated as a 2-D array with shape ``(1,n)``.
    
    Returns
    -------
    D : ndarray
        Array with `A`, `B`, `C`, ... on the diagonal.  `D` has the
        same dtype as `A`.
    
    Notes
    -----
    If all the input arrays are square, the output is known as a
    block diagonal matrix.
    
    Empty sequences (i.e., array-likes of zero size) will not be ignored.
    Noteworthy, both [] and [[]] are treated as matrices with shape ``(1,0)``.
    
    Examples
    --------
    >>> from scipy.linalg import block_diag
    >>> A = [[1, 0],
    ...      [0, 1]]
    >>> B = [[3, 4, 5],
    ...      [6, 7, 8]]
    >>> C = [[7]]
    >>> P = np.zeros((2, 0), dtype='int32')
    >>> block_diag(A, B, C)
    array([[1, 0, 0, 0, 0, 0],
           [0, 1, 0, 0, 0, 0],
           [0, 0, 3, 4, 5, 0],
           [0, 0, 6, 7, 8, 0],
           [0, 0, 0, 0, 0, 7]])
    >>> block_diag(A, P, B, C)
    array([[1, 0, 0, 0, 0, 0],
           [0, 1, 0, 0, 0, 0],
           [0, 0, 0, 0, 0, 0],
           [0, 0, 0, 0, 0, 0],
           [0, 0, 3, 4, 5, 0],
           [0, 0, 6, 7, 8, 0],
           [0, 0, 0, 0, 0, 7]])
    >>> block_diag(1.0, [2, 3], [[4, 5], [6, 7]])
    array([[ 1.,  0.,  0.,  0.,  0.],
           [ 0.,  2.,  3.,  0.,  0.],
           [ 0.,  0.,  0.,  4.,  5.],
           [ 0.,  0.,  0.,  6.,  7.]])
",function,(),(),(),(),"('(*arrs)',)"
scipy,1.1.0,scipy.linalg._solvers.cond,linalg._solvers,cond,"Python Library Documentation: function cond in module numpy.linalg.linalg

cond(x, p=None)
    Compute the condition number of a matrix.
    
    This function is capable of returning the condition number using
    one of seven different norms, depending on the value of `p` (see
    Parameters below).
    
    Parameters
    ----------
    x : (..., M, N) array_like
        The matrix whose condition number is sought.
    p : {None, 1, -1, 2, -2, inf, -inf, 'fro'}, optional
        Order of the norm:
    
        =====  ============================
        p      norm for matrices
        =====  ============================
        None   2-norm, computed directly using the ``SVD``
        'fro'  Frobenius norm
        inf    max(sum(abs(x), axis=1))
        -inf   min(sum(abs(x), axis=1))
        1      max(sum(abs(x), axis=0))
        -1     min(sum(abs(x), axis=0))
        2      2-norm (largest sing. value)
        -2     smallest singular value
        =====  ============================
    
        inf means the numpy.inf object, and the Frobenius norm is
        the root-of-sum-of-squares norm.
    
    Returns
    -------
    c : {float, inf}
        The condition number of the matrix. May be infinite.
    
    See Also
    --------
    numpy.linalg.norm
    
    Notes
    -----
    The condition number of `x` is defined as the norm of `x` times the
    norm of the inverse of `x` [1]_; the norm can be the usual L2-norm
    (root-of-sum-of-squares) or one of a number of other matrix norms.
    
    References
    ----------
    .. [1] G. Strang, *Linear Algebra and Its Applications*, Orlando, FL,
           Academic Press, Inc., 1980, pg. 285.
    
    Examples
    --------
    >>> from numpy import linalg as LA
    >>> a = np.array([[1, 0, -1], [0, 1, 0], [1, 0, 1]])
    >>> a
    array([[ 1,  0, -1],
           [ 0,  1,  0],
           [ 1,  0,  1]])
    >>> LA.cond(a)
    1.4142135623730951
    >>> LA.cond(a, 'fro')
    3.1622776601683795
    >>> LA.cond(a, np.inf)
    2.0
    >>> LA.cond(a, -np.inf)
    1.0
    >>> LA.cond(a, 1)
    2.0
    >>> LA.cond(a, -1)
    1.0
    >>> LA.cond(a, 2)
    1.4142135623730951
    >>> LA.cond(a, -2)
    0.70710678118654746
    >>> min(LA.svd(a, compute_uv=0))*min(LA.svd(LA.inv(a), compute_uv=0))
    0.70710678118654746
",function,"('(x, p=None)',)",scipy,1.1.0,scipy.linalg._solvers.cond,linalg._solvers,cond,"Python Library Documentation: function cond in module numpy.linalg.linalg

cond(x, p=None)
    Compute the condition number of a matrix.
    
    This function is capable of returning the condition number using
    one of seven different norms, depending on the value of `p` (see
    Parameters below).
    
    Parameters
    ----------
    x : (..., M, N) array_like
        The matrix whose condition number is sought.
    p : {None, 1, -1, 2, -2, inf, -inf, 'fro'}, optional
        Order of the norm:
    
        =====  ============================
        p      norm for matrices
        =====  ============================
        None   2-norm, computed directly using the ``SVD``
        'fro'  Frobenius norm
        inf    max(sum(abs(x), axis=1))
        -inf   min(sum(abs(x), axis=1))
        1      max(sum(abs(x), axis=0))
        -1     min(sum(abs(x), axis=0))
        2      2-norm (largest sing. value)
        -2     smallest singular value
        =====  ============================
    
        inf means the numpy.inf object, and the Frobenius norm is
        the root-of-sum-of-squares norm.
    
    Returns
    -------
    c : {float, inf}
        The condition number of the matrix. May be infinite.
    
    See Also
    --------
    numpy.linalg.norm
    
    Notes
    -----
    The condition number of `x` is defined as the norm of `x` times the
    norm of the inverse of `x` [1]_; the norm can be the usual L2-norm
    (root-of-sum-of-squares) or one of a number of other matrix norms.
    
    References
    ----------
    .. [1] G. Strang, *Linear Algebra and Its Applications*, Orlando, FL,
           Academic Press, Inc., 1980, pg. 285.
    
    Examples
    --------
    >>> from numpy import linalg as LA
    >>> a = np.array([[1, 0, -1], [0, 1, 0], [1, 0, 1]])
    >>> a
    array([[ 1,  0, -1],
           [ 0,  1,  0],
           [ 1,  0,  1]])
    >>> LA.cond(a)
    1.4142135623730951
    >>> LA.cond(a, 'fro')
    3.1622776601683795
    >>> LA.cond(a, np.inf)
    2.0
    >>> LA.cond(a, -np.inf)
    1.0
    >>> LA.cond(a, 1)
    2.0
    >>> LA.cond(a, -1)
    1.0
    >>> LA.cond(a, 2)
    1.4142135623730951
    >>> LA.cond(a, -2)
    0.70710678118654746
    >>> min(LA.svd(a, compute_uv=0))*min(LA.svd(LA.inv(a), compute_uv=0))
    0.70710678118654746
",function,"('x', 'p')","(nan, None)","(nan, 'NoneType')","('arg_info', 'arg_info')","('(x, p=None)',)"
scipy,1.1.0,scipy.linalg._solvers.get_lapack_funcs,linalg._solvers,get_lapack_funcs,"Python Library Documentation: function get_lapack_funcs in module scipy.linalg.lapack

get_lapack_funcs(names, arrays=(), dtype=None)
    Return available LAPACK function objects from names.
    
    Arrays are used to determine the optimal prefix of LAPACK routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of LAPACK functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of LAPACK
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In LAPACK, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively, and
    are stored in attribute ``typecode`` of the returned functions.
    
    Examples
    --------
    Suppose we would like to use '?lange' routine which computes the selected
    norm of an array. We pass our array in order to get the correct 'lange'
    flavor.
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_lange = LA.get_lapack_funcs('lange', (a,))
    >>> x_lange.typecode
    'd'
    >>> x_lange = LA.get_lapack_funcs('lange',(a*1j,))
    >>> x_lange.typecode
    'z'
    
    Several LAPACK routines work best when its internal WORK array has
    the optimal size (big enough for fast computation and small enough to
    avoid waste of memory). This size is determined also by a dedicated query
    to the function which is often wrapped as a standalone function and
    commonly denoted as ``###_lwork``. Below is an example for ``?sysv``
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(1000,1000)
    >>> b = np.random.rand(1000,1)*1j
    >>> # We pick up zsysv and zsysv_lwork due to b array
    ... xsysv, xlwork = LA.get_lapack_funcs(('sysv', 'sysv_lwork'), (a, b))
    >>> opt_lwork, _ = xlwork(a.shape[0])  # returns a complex for 'z' prefix
    >>> udut, ipiv, x, info = xsysv(a, b, lwork=int(opt_lwork.real))
",function,"('(names, arrays=(), dtype=None)',)",scipy,1.1.0,scipy.linalg._solvers.get_lapack_funcs,linalg._solvers,get_lapack_funcs,"Python Library Documentation: function get_lapack_funcs in module scipy.linalg.lapack

get_lapack_funcs(names, arrays=(), dtype=None)
    Return available LAPACK function objects from names.
    
    Arrays are used to determine the optimal prefix of LAPACK routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of LAPACK functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of LAPACK
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In LAPACK, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively, and
    are stored in attribute ``typecode`` of the returned functions.
    
    Examples
    --------
    Suppose we would like to use '?lange' routine which computes the selected
    norm of an array. We pass our array in order to get the correct 'lange'
    flavor.
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_lange = LA.get_lapack_funcs('lange', (a,))
    >>> x_lange.typecode
    'd'
    >>> x_lange = LA.get_lapack_funcs('lange',(a*1j,))
    >>> x_lange.typecode
    'z'
    
    Several LAPACK routines work best when its internal WORK array has
    the optimal size (big enough for fast computation and small enough to
    avoid waste of memory). This size is determined also by a dedicated query
    to the function which is often wrapped as a standalone function and
    commonly denoted as ``###_lwork``. Below is an example for ``?sysv``
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(1000,1000)
    >>> b = np.random.rand(1000,1)*1j
    >>> # We pick up zsysv and zsysv_lwork due to b array
    ... xsysv, xlwork = LA.get_lapack_funcs(('sysv', 'sysv_lwork'), (a, b))
    >>> opt_lwork, _ = xlwork(a.shape[0])  # returns a complex for 'z' prefix
    >>> udut, ipiv, x, info = xsysv(a, b, lwork=int(opt_lwork.real))
",function,"('names', 'arrays', 'dtype')","(nan, (), None)","(nan, 'tuple', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(names, arrays=(), dtype=None)',)"
scipy,1.1.0,scipy.linalg._solvers.inv,linalg._solvers,inv,"Python Library Documentation: function inv in module numpy.linalg.linalg

inv(a)
    Compute the (multiplicative) inverse of a matrix.
    
    Given a square matrix `a`, return the matrix `ainv` satisfying
    ``dot(a, ainv) = dot(ainv, a) = eye(a.shape[0])``.
    
    Parameters
    ----------
    a : (..., M, M) array_like
        Matrix to be inverted.
    
    Returns
    -------
    ainv : (..., M, M) ndarray or matrix
        (Multiplicative) inverse of the matrix `a`.
    
    Raises
    ------
    LinAlgError
        If `a` is not square or inversion fails.
    
    Notes
    -----
    
    .. versionadded:: 1.8.0
    
    Broadcasting rules apply, see the `numpy.linalg` documentation for
    details.
    
    Examples
    --------
    >>> from numpy.linalg import inv
    >>> a = np.array([[1., 2.], [3., 4.]])
    >>> ainv = inv(a)
    >>> np.allclose(np.dot(a, ainv), np.eye(2))
    True
    >>> np.allclose(np.dot(ainv, a), np.eye(2))
    True
    
    If a is a matrix object, then the return value is a matrix as well:
    
    >>> ainv = inv(np.matrix(a))
    >>> ainv
    matrix([[-2. ,  1. ],
            [ 1.5, -0.5]])
    
    Inverses of several matrices can be computed at once:
    
    >>> a = np.array([[[1., 2.], [3., 4.]], [[1, 3], [3, 5]]])
    >>> inv(a)
    array([[[-2. ,  1. ],
            [ 1.5, -0.5]],
           [[-5. ,  2. ],
            [ 3. , -1. ]]])
",function,"('(a)',)",scipy,1.1.0,scipy.linalg._solvers.inv,linalg._solvers,inv,"Python Library Documentation: function inv in module numpy.linalg.linalg

inv(a)
    Compute the (multiplicative) inverse of a matrix.
    
    Given a square matrix `a`, return the matrix `ainv` satisfying
    ``dot(a, ainv) = dot(ainv, a) = eye(a.shape[0])``.
    
    Parameters
    ----------
    a : (..., M, M) array_like
        Matrix to be inverted.
    
    Returns
    -------
    ainv : (..., M, M) ndarray or matrix
        (Multiplicative) inverse of the matrix `a`.
    
    Raises
    ------
    LinAlgError
        If `a` is not square or inversion fails.
    
    Notes
    -----
    
    .. versionadded:: 1.8.0
    
    Broadcasting rules apply, see the `numpy.linalg` documentation for
    details.
    
    Examples
    --------
    >>> from numpy.linalg import inv
    >>> a = np.array([[1., 2.], [3., 4.]])
    >>> ainv = inv(a)
    >>> np.allclose(np.dot(a, ainv), np.eye(2))
    True
    >>> np.allclose(np.dot(ainv, a), np.eye(2))
    True
    
    If a is a matrix object, then the return value is a matrix as well:
    
    >>> ainv = inv(np.matrix(a))
    >>> ainv
    matrix([[-2. ,  1. ],
            [ 1.5, -0.5]])
    
    Inverses of several matrices can be computed at once:
    
    >>> a = np.array([[[1., 2.], [3., 4.]], [[1, 3], [3, 5]]])
    >>> inv(a)
    array([[[-2. ,  1. ],
            [ 1.5, -0.5]],
           [[-5. ,  2. ],
            [ 3. , -1. ]]])
",function,"('a',)","(nan,)","(nan,)","('arg_info',)","('(a)',)"
scipy,1.1.0,scipy.linalg._solvers.kron,linalg._solvers,kron,"Python Library Documentation: function kron in module scipy.linalg.special_matrices

kron(a, b)
    Kronecker product.
    
    The result is the block matrix::
    
        a[0,0]*b    a[0,1]*b  ... a[0,-1]*b
        a[1,0]*b    a[1,1]*b  ... a[1,-1]*b
        ...
        a[-1,0]*b   a[-1,1]*b ... a[-1,-1]*b
    
    Parameters
    ----------
    a : (M, N) ndarray
        Input array
    b : (P, Q) ndarray
        Input array
    
    Returns
    -------
    A : (M*P, N*Q) ndarray
        Kronecker product of `a` and `b`.
    
    Examples
    --------
    >>> from numpy import array
    >>> from scipy.linalg import kron
    >>> kron(array([[1,2],[3,4]]), array([[1,1,1]]))
    array([[1, 1, 1, 2, 2, 2],
           [3, 3, 3, 4, 4, 4]])
",function,"('(a, b)',)",scipy,1.1.0,scipy.linalg._solvers.kron,linalg._solvers,kron,"Python Library Documentation: function kron in module scipy.linalg.special_matrices

kron(a, b)
    Kronecker product.
    
    The result is the block matrix::
    
        a[0,0]*b    a[0,1]*b  ... a[0,-1]*b
        a[1,0]*b    a[1,1]*b  ... a[1,-1]*b
        ...
        a[-1,0]*b   a[-1,1]*b ... a[-1,-1]*b
    
    Parameters
    ----------
    a : (M, N) ndarray
        Input array
    b : (P, Q) ndarray
        Input array
    
    Returns
    -------
    A : (M*P, N*Q) ndarray
        Kronecker product of `a` and `b`.
    
    Examples
    --------
    >>> from numpy import array
    >>> from scipy.linalg import kron
    >>> kron(array([[1,2],[3,4]]), array([[1,1,1]]))
    array([[1, 1, 1, 2, 2, 2],
           [3, 3, 3, 4, 4, 4]])
",function,"('a', 'b')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(a, b)',)"
scipy,1.1.0,scipy.linalg._solvers.lu,linalg._solvers,lu,"Python Library Documentation: function lu in module scipy.linalg.decomp_lu

lu(a, permute_l=False, overwrite_a=False, check_finite=True)
    Compute pivoted LU decomposition of a matrix.
    
    The decomposition is::
    
        A = P L U
    
    where P is a permutation matrix, L lower triangular with unit
    diagonal elements, and U upper triangular.
    
    Parameters
    ----------
    a : (M, N) array_like
        Array to decompose
    permute_l : bool, optional
        Perform the multiplication P*L  (Default: do not permute)
    overwrite_a : bool, optional
        Whether to overwrite data in a (may improve performance)
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    **(If permute_l == False)**
    
    p : (M, M) ndarray
        Permutation matrix
    l : (M, K) ndarray
        Lower triangular or trapezoidal matrix with unit diagonal.
        K = min(M, N)
    u : (K, N) ndarray
        Upper triangular or trapezoidal matrix
    
    **(If permute_l == True)**
    
    pl : (M, K) ndarray
        Permuted L matrix.
        K = min(M, N)
    u : (K, N) ndarray
        Upper triangular or trapezoidal matrix
    
    Notes
    -----
    This is a LU factorization routine written for Scipy.
    
    Examples
    --------
    >>> from scipy.linalg import lu
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> p, l, u = lu(A)
    >>> np.allclose(A - p @ l @ u, np.zeros((4, 4)))
    True
",function,"('(a, permute_l=False, overwrite_a=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg._solvers.lu,linalg._solvers,lu,"Python Library Documentation: function lu in module scipy.linalg.decomp_lu

lu(a, permute_l=False, overwrite_a=False, check_finite=True)
    Compute pivoted LU decomposition of a matrix.
    
    The decomposition is::
    
        A = P L U
    
    where P is a permutation matrix, L lower triangular with unit
    diagonal elements, and U upper triangular.
    
    Parameters
    ----------
    a : (M, N) array_like
        Array to decompose
    permute_l : bool, optional
        Perform the multiplication P*L  (Default: do not permute)
    overwrite_a : bool, optional
        Whether to overwrite data in a (may improve performance)
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    **(If permute_l == False)**
    
    p : (M, M) ndarray
        Permutation matrix
    l : (M, K) ndarray
        Lower triangular or trapezoidal matrix with unit diagonal.
        K = min(M, N)
    u : (K, N) ndarray
        Upper triangular or trapezoidal matrix
    
    **(If permute_l == True)**
    
    pl : (M, K) ndarray
        Permuted L matrix.
        K = min(M, N)
    u : (K, N) ndarray
        Upper triangular or trapezoidal matrix
    
    Notes
    -----
    This is a LU factorization routine written for Scipy.
    
    Examples
    --------
    >>> from scipy.linalg import lu
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> p, l, u = lu(A)
    >>> np.allclose(A - p @ l @ u, np.zeros((4, 4)))
    True
",function,"('a', 'permute_l', 'overwrite_a', 'check_finite')","(nan, False, False, True)","(nan, 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, permute_l=False, overwrite_a=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg._solvers.matrix_balance,linalg._solvers,matrix_balance,"Python Library Documentation: function matrix_balance in module scipy.linalg.basic

matrix_balance(A, permute=True, scale=True, separate=False, overwrite_a=False)
    Compute a diagonal similarity transformation for row/column balancing.
    
    The balancing tries to equalize the row and column 1-norms by applying
    a similarity transformation such that the magnitude variation of the
    matrix entries is reflected to the scaling matrices.
    
    Moreover, if enabled, the matrix is first permuted to isolate the upper
    triangular parts of the matrix and, again if scaling is also enabled,
    only the remaining subblocks are subjected to scaling.
    
    The balanced matrix satisfies the following equality
    
    .. math::
    
                        B = T^{-1} A T
    
    The scaling coefficients are approximated to the nearest power of 2
    to avoid round-off errors.
    
    Parameters
    ----------
    A : (n, n) array_like
        Square data matrix for the balancing.
    permute : bool, optional
        The selector to define whether permutation of A is also performed
        prior to scaling.
    scale : bool, optional
        The selector to turn on and off the scaling. If False, the matrix
        will not be scaled.
    separate : bool, optional
        This switches from returning a full matrix of the transformation
        to a tuple of two separate 1D permutation and scaling arrays.
    overwrite_a : bool, optional
        This is passed to xGEBAL directly. Essentially, overwrites the result
        to the data. It might increase the space efficiency. See LAPACK manual
        for details. This is False by default.
    
    Returns
    -------
    B : (n, n) ndarray
        Balanced matrix
    T : (n, n) ndarray
        A possibly permuted diagonal matrix whose nonzero entries are
        integer powers of 2 to avoid numerical truncation errors.
    scale, perm : (n,) ndarray
        If ``separate`` keyword is set to True then instead of the array
        ``T`` above, the scaling and the permutation vectors are given
        separately as a tuple without allocating the full array ``T``.
    
    .. versionadded:: 0.19.0
    
    Notes
    -----
    
    This algorithm is particularly useful for eigenvalue and matrix
    decompositions and in many cases it is already called by various
    LAPACK routines.
    
    The algorithm is based on the well-known technique of [1]_ and has
    been modified to account for special cases. See [2]_ for details
    which have been implemented since LAPACK v3.5.0. Before this version
    there are corner cases where balancing can actually worsen the
    conditioning. See [3]_ for such examples.
    
    The code is a wrapper around LAPACK's xGEBAL routine family for matrix
    balancing.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> x = np.array([[1,2,0], [9,1,0.01], [1,2,10*np.pi]])
    
    >>> y, permscale = linalg.matrix_balance(x)
    >>> np.abs(x).sum(axis=0) / np.abs(x).sum(axis=1)
    array([ 3.66666667,  0.4995005 ,  0.91312162])
    
    >>> np.abs(y).sum(axis=0) / np.abs(y).sum(axis=1)
    array([ 1.2       ,  1.27041742,  0.92658316])  # may vary
    
    >>> permscale  # only powers of 2 (0.5 == 2^(-1))
    array([[  0.5,   0. ,  0. ],  # may vary
           [  0. ,   1. ,  0. ],
           [  0. ,   0. ,  1. ]])
    
    References
    ----------
    .. [1] : B.N. Parlett and C. Reinsch, ""Balancing a Matrix for
       Calculation of Eigenvalues and Eigenvectors"", Numerische Mathematik,
       Vol.13(4), 1969, DOI:10.1007/BF02165404
    
    .. [2] : R. James, J. Langou, B.R. Lowery, ""On matrix balancing and
       eigenvector computation"", 2014, Available online:
       http://arxiv.org/abs/1401.5766
    
    .. [3] :  D.S. Watkins. A case where balancing is harmful.
       Electron. Trans. Numer. Anal, Vol.23, 2006.
",function,"('(A, permute=True, scale=True, separate=False, overwrite_a=False)',)",scipy,1.1.0,scipy.linalg._solvers.matrix_balance,linalg._solvers,matrix_balance,"Python Library Documentation: function matrix_balance in module scipy.linalg.basic

matrix_balance(A, permute=True, scale=True, separate=False, overwrite_a=False)
    Compute a diagonal similarity transformation for row/column balancing.
    
    The balancing tries to equalize the row and column 1-norms by applying
    a similarity transformation such that the magnitude variation of the
    matrix entries is reflected to the scaling matrices.
    
    Moreover, if enabled, the matrix is first permuted to isolate the upper
    triangular parts of the matrix and, again if scaling is also enabled,
    only the remaining subblocks are subjected to scaling.
    
    The balanced matrix satisfies the following equality
    
    .. math::
    
                        B = T^{-1} A T
    
    The scaling coefficients are approximated to the nearest power of 2
    to avoid round-off errors.
    
    Parameters
    ----------
    A : (n, n) array_like
        Square data matrix for the balancing.
    permute : bool, optional
        The selector to define whether permutation of A is also performed
        prior to scaling.
    scale : bool, optional
        The selector to turn on and off the scaling. If False, the matrix
        will not be scaled.
    separate : bool, optional
        This switches from returning a full matrix of the transformation
        to a tuple of two separate 1D permutation and scaling arrays.
    overwrite_a : bool, optional
        This is passed to xGEBAL directly. Essentially, overwrites the result
        to the data. It might increase the space efficiency. See LAPACK manual
        for details. This is False by default.
    
    Returns
    -------
    B : (n, n) ndarray
        Balanced matrix
    T : (n, n) ndarray
        A possibly permuted diagonal matrix whose nonzero entries are
        integer powers of 2 to avoid numerical truncation errors.
    scale, perm : (n,) ndarray
        If ``separate`` keyword is set to True then instead of the array
        ``T`` above, the scaling and the permutation vectors are given
        separately as a tuple without allocating the full array ``T``.
    
    .. versionadded:: 0.19.0
    
    Notes
    -----
    
    This algorithm is particularly useful for eigenvalue and matrix
    decompositions and in many cases it is already called by various
    LAPACK routines.
    
    The algorithm is based on the well-known technique of [1]_ and has
    been modified to account for special cases. See [2]_ for details
    which have been implemented since LAPACK v3.5.0. Before this version
    there are corner cases where balancing can actually worsen the
    conditioning. See [3]_ for such examples.
    
    The code is a wrapper around LAPACK's xGEBAL routine family for matrix
    balancing.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> x = np.array([[1,2,0], [9,1,0.01], [1,2,10*np.pi]])
    
    >>> y, permscale = linalg.matrix_balance(x)
    >>> np.abs(x).sum(axis=0) / np.abs(x).sum(axis=1)
    array([ 3.66666667,  0.4995005 ,  0.91312162])
    
    >>> np.abs(y).sum(axis=0) / np.abs(y).sum(axis=1)
    array([ 1.2       ,  1.27041742,  0.92658316])  # may vary
    
    >>> permscale  # only powers of 2 (0.5 == 2^(-1))
    array([[  0.5,   0. ,  0. ],  # may vary
           [  0. ,   1. ,  0. ],
           [  0. ,   0. ,  1. ]])
    
    References
    ----------
    .. [1] : B.N. Parlett and C. Reinsch, ""Balancing a Matrix for
       Calculation of Eigenvalues and Eigenvectors"", Numerische Mathematik,
       Vol.13(4), 1969, DOI:10.1007/BF02165404
    
    .. [2] : R. James, J. Langou, B.R. Lowery, ""On matrix balancing and
       eigenvector computation"", 2014, Available online:
       http://arxiv.org/abs/1401.5766
    
    .. [3] :  D.S. Watkins. A case where balancing is harmful.
       Electron. Trans. Numer. Anal, Vol.23, 2006.
",function,"('A', 'permute', 'scale', 'separate', 'overwrite_a')","(nan, True, True, False, False)","(nan, 'bool', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(A, permute=True, scale=True, separate=False, overwrite_a=False)',)"
scipy,1.1.0,scipy.linalg._solvers.norm,linalg._solvers,norm,"Python Library Documentation: function norm in module numpy.linalg.linalg

norm(x, ord=None, axis=None, keepdims=False)
    Matrix or vector norm.
    
    This function is able to return one of eight different matrix norms,
    or one of an infinite number of vector norms (described below), depending
    on the value of the ``ord`` parameter.
    
    Parameters
    ----------
    x : array_like
        Input array.  If `axis` is None, `x` must be 1-D or 2-D.
    ord : {non-zero int, inf, -inf, 'fro', 'nuc'}, optional
        Order of the norm (see table under ``Notes``). inf means numpy's
        `inf` object.
    axis : {int, 2-tuple of ints, None}, optional
        If `axis` is an integer, it specifies the axis of `x` along which to
        compute the vector norms.  If `axis` is a 2-tuple, it specifies the
        axes that hold 2-D matrices, and the matrix norms of these matrices
        are computed.  If `axis` is None then either a vector norm (when `x`
        is 1-D) or a matrix norm (when `x` is 2-D) is returned.
    keepdims : bool, optional
        If this is set to True, the axes which are normed over are left in the
        result as dimensions with size one.  With this option the result will
        broadcast correctly against the original `x`.
    
        .. versionadded:: 1.10.0
    
    Returns
    -------
    n : float or ndarray
        Norm of the matrix or vector(s).
    
    Notes
    -----
    For values of ``ord <= 0``, the result is, strictly speaking, not a
    mathematical 'norm', but it may still be useful for various numerical
    purposes.
    
    The following norms can be calculated:
    
    =====  ============================  ==========================
    ord    norm for matrices             norm for vectors
    =====  ============================  ==========================
    None   Frobenius norm                2-norm
    'fro'  Frobenius norm                --
    'nuc'  nuclear norm                  --
    inf    max(sum(abs(x), axis=1))      max(abs(x))
    -inf   min(sum(abs(x), axis=1))      min(abs(x))
    0      --                            sum(x != 0)
    1      max(sum(abs(x), axis=0))      as below
    -1     min(sum(abs(x), axis=0))      as below
    2      2-norm (largest sing. value)  as below
    -2     smallest singular value       as below
    other  --                            sum(abs(x)**ord)**(1./ord)
    =====  ============================  ==========================
    
    The Frobenius norm is given by [1]_:
    
        :math:`||A||_F = [\sum_{i,j} abs(a_{i,j})^2]^{1/2}`
    
    The nuclear norm is the sum of the singular values.
    
    References
    ----------
    .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*,
           Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15
    
    Examples
    --------
    >>> from numpy import linalg as LA
    >>> a = np.arange(9) - 4
    >>> a
    array([-4, -3, -2, -1,  0,  1,  2,  3,  4])
    >>> b = a.reshape((3, 3))
    >>> b
    array([[-4, -3, -2],
           [-1,  0,  1],
           [ 2,  3,  4]])
    
    >>> LA.norm(a)
    7.745966692414834
    >>> LA.norm(b)
    7.745966692414834
    >>> LA.norm(b, 'fro')
    7.745966692414834
    >>> LA.norm(a, np.inf)
    4.0
    >>> LA.norm(b, np.inf)
    9.0
    >>> LA.norm(a, -np.inf)
    0.0
    >>> LA.norm(b, -np.inf)
    2.0
    
    >>> LA.norm(a, 1)
    20.0
    >>> LA.norm(b, 1)
    7.0
    >>> LA.norm(a, -1)
    -4.6566128774142013e-010
    >>> LA.norm(b, -1)
    6.0
    >>> LA.norm(a, 2)
    7.745966692414834
    >>> LA.norm(b, 2)
    7.3484692283495345
    
    >>> LA.norm(a, -2)
    nan
    >>> LA.norm(b, -2)
    1.8570331885190563e-016
    >>> LA.norm(a, 3)
    5.8480354764257312
    >>> LA.norm(a, -3)
    nan
    
    Using the `axis` argument to compute vector norms:
    
    >>> c = np.array([[ 1, 2, 3],
    ...               [-1, 1, 4]])
    >>> LA.norm(c, axis=0)
    array([ 1.41421356,  2.23606798,  5.        ])
    >>> LA.norm(c, axis=1)
    array([ 3.74165739,  4.24264069])
    >>> LA.norm(c, ord=1, axis=1)
    array([ 6.,  6.])
    
    Using the `axis` argument to compute matrix norms:
    
    >>> m = np.arange(8).reshape(2,2,2)
    >>> LA.norm(m, axis=(1,2))
    array([  3.74165739,  11.22497216])
    >>> LA.norm(m[0, :, :]), LA.norm(m[1, :, :])
    (3.7416573867739413, 11.224972160321824)
",function,"('(x, ord=None, axis=None, keepdims=False)',)",scipy,1.1.0,scipy.linalg._solvers.norm,linalg._solvers,norm,"Python Library Documentation: function norm in module numpy.linalg.linalg

norm(x, ord=None, axis=None, keepdims=False)
    Matrix or vector norm.
    
    This function is able to return one of eight different matrix norms,
    or one of an infinite number of vector norms (described below), depending
    on the value of the ``ord`` parameter.
    
    Parameters
    ----------
    x : array_like
        Input array.  If `axis` is None, `x` must be 1-D or 2-D.
    ord : {non-zero int, inf, -inf, 'fro', 'nuc'}, optional
        Order of the norm (see table under ``Notes``). inf means numpy's
        `inf` object.
    axis : {int, 2-tuple of ints, None}, optional
        If `axis` is an integer, it specifies the axis of `x` along which to
        compute the vector norms.  If `axis` is a 2-tuple, it specifies the
        axes that hold 2-D matrices, and the matrix norms of these matrices
        are computed.  If `axis` is None then either a vector norm (when `x`
        is 1-D) or a matrix norm (when `x` is 2-D) is returned.
    keepdims : bool, optional
        If this is set to True, the axes which are normed over are left in the
        result as dimensions with size one.  With this option the result will
        broadcast correctly against the original `x`.
    
        .. versionadded:: 1.10.0
    
    Returns
    -------
    n : float or ndarray
        Norm of the matrix or vector(s).
    
    Notes
    -----
    For values of ``ord <= 0``, the result is, strictly speaking, not a
    mathematical 'norm', but it may still be useful for various numerical
    purposes.
    
    The following norms can be calculated:
    
    =====  ============================  ==========================
    ord    norm for matrices             norm for vectors
    =====  ============================  ==========================
    None   Frobenius norm                2-norm
    'fro'  Frobenius norm                --
    'nuc'  nuclear norm                  --
    inf    max(sum(abs(x), axis=1))      max(abs(x))
    -inf   min(sum(abs(x), axis=1))      min(abs(x))
    0      --                            sum(x != 0)
    1      max(sum(abs(x), axis=0))      as below
    -1     min(sum(abs(x), axis=0))      as below
    2      2-norm (largest sing. value)  as below
    -2     smallest singular value       as below
    other  --                            sum(abs(x)**ord)**(1./ord)
    =====  ============================  ==========================
    
    The Frobenius norm is given by [1]_:
    
        :math:`||A||_F = [\sum_{i,j} abs(a_{i,j})^2]^{1/2}`
    
    The nuclear norm is the sum of the singular values.
    
    References
    ----------
    .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*,
           Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15
    
    Examples
    --------
    >>> from numpy import linalg as LA
    >>> a = np.arange(9) - 4
    >>> a
    array([-4, -3, -2, -1,  0,  1,  2,  3,  4])
    >>> b = a.reshape((3, 3))
    >>> b
    array([[-4, -3, -2],
           [-1,  0,  1],
           [ 2,  3,  4]])
    
    >>> LA.norm(a)
    7.745966692414834
    >>> LA.norm(b)
    7.745966692414834
    >>> LA.norm(b, 'fro')
    7.745966692414834
    >>> LA.norm(a, np.inf)
    4.0
    >>> LA.norm(b, np.inf)
    9.0
    >>> LA.norm(a, -np.inf)
    0.0
    >>> LA.norm(b, -np.inf)
    2.0
    
    >>> LA.norm(a, 1)
    20.0
    >>> LA.norm(b, 1)
    7.0
    >>> LA.norm(a, -1)
    -4.6566128774142013e-010
    >>> LA.norm(b, -1)
    6.0
    >>> LA.norm(a, 2)
    7.745966692414834
    >>> LA.norm(b, 2)
    7.3484692283495345
    
    >>> LA.norm(a, -2)
    nan
    >>> LA.norm(b, -2)
    1.8570331885190563e-016
    >>> LA.norm(a, 3)
    5.8480354764257312
    >>> LA.norm(a, -3)
    nan
    
    Using the `axis` argument to compute vector norms:
    
    >>> c = np.array([[ 1, 2, 3],
    ...               [-1, 1, 4]])
    >>> LA.norm(c, axis=0)
    array([ 1.41421356,  2.23606798,  5.        ])
    >>> LA.norm(c, axis=1)
    array([ 3.74165739,  4.24264069])
    >>> LA.norm(c, ord=1, axis=1)
    array([ 6.,  6.])
    
    Using the `axis` argument to compute matrix norms:
    
    >>> m = np.arange(8).reshape(2,2,2)
    >>> LA.norm(m, axis=(1,2))
    array([  3.74165739,  11.22497216])
    >>> LA.norm(m[0, :, :]), LA.norm(m[1, :, :])
    (3.7416573867739413, 11.224972160321824)
",function,"('x', 'ord', 'axis', 'keepdims')","(nan, None, None, False)","(nan, 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, ord=None, axis=None, keepdims=False)',)"
scipy,1.1.0,scipy.linalg._solvers.ordqz,linalg._solvers,ordqz,"Python Library Documentation: function ordqz in module scipy.linalg._decomp_qz

ordqz(A, B, sort='lhp', output='real', overwrite_a=False, overwrite_b=False, check_finite=True)
    QZ decomposition for a pair of matrices with reordering.
    
    .. versionadded:: 0.17.0
    
    Parameters
    ----------
    A : (N, N) array_like
        2d array to decompose
    B : (N, N) array_like
        2d array to decompose
    sort : {callable, 'lhp', 'rhp', 'iuc', 'ouc'}, optional
        Specifies whether the upper eigenvalues should be sorted. A
        callable may be passed that, given an ordered pair ``(alpha,
        beta)`` representing the eigenvalue ``x = (alpha/beta)``,
        returns a boolean denoting whether the eigenvalue should be
        sorted to the top-left (True). For the real matrix pairs
        ``beta`` is real while ``alpha`` can be complex, and for
        complex matrix pairs both ``alpha`` and ``beta`` can be
        complex. The callable must be able to accept a numpy
        array. Alternatively, string parameters may be used:
    
            - 'lhp'   Left-hand plane (x.real < 0.0)
            - 'rhp'   Right-hand plane (x.real > 0.0)
            - 'iuc'   Inside the unit circle (x*x.conjugate() < 1.0)
            - 'ouc'   Outside the unit circle (x*x.conjugate() > 1.0)
    
        With the predefined sorting functions, an infinite eigenvalue
        (i.e. ``alpha != 0`` and ``beta = 0``) is considered to lie in
        neither the left-hand nor the right-hand plane, but it is
        considered to lie outside the unit circle. For the eigenvalue
        ``(alpha, beta) = (0, 0)`` the predefined sorting functions
        all return `False`.
    output : str {'real','complex'}, optional
        Construct the real or complex QZ decomposition for real matrices.
        Default is 'real'.
    overwrite_a : bool, optional
        If True, the contents of A are overwritten.
    overwrite_b : bool, optional
        If True, the contents of B are overwritten.
    check_finite : bool, optional
        If true checks the elements of `A` and `B` are finite numbers. If
        false does no checking and passes matrix through to
        underlying algorithm.
    
    Returns
    -------
    AA : (N, N) ndarray
        Generalized Schur form of A.
    BB : (N, N) ndarray
        Generalized Schur form of B.
    alpha : (N,) ndarray
        alpha = alphar + alphai * 1j. See notes.
    beta : (N,) ndarray
        See notes.
    Q : (N, N) ndarray
        The left Schur vectors.
    Z : (N, N) ndarray
        The right Schur vectors.
    
    Notes
    -----
    On exit, ``(ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N``, will be the
    generalized eigenvalues.  ``ALPHAR(j) + ALPHAI(j)*i`` and
    ``BETA(j),j=1,...,N`` are the diagonals of the complex Schur form (S,T)
    that would result if the 2-by-2 diagonal blocks of the real generalized
    Schur form of (A,B) were further reduced to triangular form using complex
    unitary transformations. If ALPHAI(j) is zero, then the j-th eigenvalue is
    real; if positive, then the ``j``-th and ``(j+1)``-st eigenvalues are a
    complex conjugate pair, with ``ALPHAI(j+1)`` negative.
    
    See also
    --------
    qz
    
    Examples
    --------
    >>> from scipy.linalg import ordqz
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> B = np.array([[0, 6, 0, 0], [5, 0, 2, 1], [5, 2, 6, 6], [4, 7, 7, 7]])
    >>> AA, BB, alpha, beta, Q, Z = ordqz(A, B, sort='lhp')
    
    Since we have sorted for left half plane eigenvalues, negatives come first
    
    >>> (alpha/beta).real < 0
    array([ True,  True, False, False], dtype=bool)
",function,"(""(A, B, sort='lhp', output='real', overwrite_a=False, overwrite_b=False, check_finite=True)"",)",scipy,1.1.0,scipy.linalg._solvers.ordqz,linalg._solvers,ordqz,"Python Library Documentation: function ordqz in module scipy.linalg._decomp_qz

ordqz(A, B, sort='lhp', output='real', overwrite_a=False, overwrite_b=False, check_finite=True)
    QZ decomposition for a pair of matrices with reordering.
    
    .. versionadded:: 0.17.0
    
    Parameters
    ----------
    A : (N, N) array_like
        2d array to decompose
    B : (N, N) array_like
        2d array to decompose
    sort : {callable, 'lhp', 'rhp', 'iuc', 'ouc'}, optional
        Specifies whether the upper eigenvalues should be sorted. A
        callable may be passed that, given an ordered pair ``(alpha,
        beta)`` representing the eigenvalue ``x = (alpha/beta)``,
        returns a boolean denoting whether the eigenvalue should be
        sorted to the top-left (True). For the real matrix pairs
        ``beta`` is real while ``alpha`` can be complex, and for
        complex matrix pairs both ``alpha`` and ``beta`` can be
        complex. The callable must be able to accept a numpy
        array. Alternatively, string parameters may be used:
    
            - 'lhp'   Left-hand plane (x.real < 0.0)
            - 'rhp'   Right-hand plane (x.real > 0.0)
            - 'iuc'   Inside the unit circle (x*x.conjugate() < 1.0)
            - 'ouc'   Outside the unit circle (x*x.conjugate() > 1.0)
    
        With the predefined sorting functions, an infinite eigenvalue
        (i.e. ``alpha != 0`` and ``beta = 0``) is considered to lie in
        neither the left-hand nor the right-hand plane, but it is
        considered to lie outside the unit circle. For the eigenvalue
        ``(alpha, beta) = (0, 0)`` the predefined sorting functions
        all return `False`.
    output : str {'real','complex'}, optional
        Construct the real or complex QZ decomposition for real matrices.
        Default is 'real'.
    overwrite_a : bool, optional
        If True, the contents of A are overwritten.
    overwrite_b : bool, optional
        If True, the contents of B are overwritten.
    check_finite : bool, optional
        If true checks the elements of `A` and `B` are finite numbers. If
        false does no checking and passes matrix through to
        underlying algorithm.
    
    Returns
    -------
    AA : (N, N) ndarray
        Generalized Schur form of A.
    BB : (N, N) ndarray
        Generalized Schur form of B.
    alpha : (N,) ndarray
        alpha = alphar + alphai * 1j. See notes.
    beta : (N,) ndarray
        See notes.
    Q : (N, N) ndarray
        The left Schur vectors.
    Z : (N, N) ndarray
        The right Schur vectors.
    
    Notes
    -----
    On exit, ``(ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N``, will be the
    generalized eigenvalues.  ``ALPHAR(j) + ALPHAI(j)*i`` and
    ``BETA(j),j=1,...,N`` are the diagonals of the complex Schur form (S,T)
    that would result if the 2-by-2 diagonal blocks of the real generalized
    Schur form of (A,B) were further reduced to triangular form using complex
    unitary transformations. If ALPHAI(j) is zero, then the j-th eigenvalue is
    real; if positive, then the ``j``-th and ``(j+1)``-st eigenvalues are a
    complex conjugate pair, with ``ALPHAI(j+1)`` negative.
    
    See also
    --------
    qz
    
    Examples
    --------
    >>> from scipy.linalg import ordqz
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> B = np.array([[0, 6, 0, 0], [5, 0, 2, 1], [5, 2, 6, 6], [4, 7, 7, 7]])
    >>> AA, BB, alpha, beta, Q, Z = ordqz(A, B, sort='lhp')
    
    Since we have sorted for left half plane eigenvalues, negatives come first
    
    >>> (alpha/beta).real < 0
    array([ True,  True, False, False], dtype=bool)
",function,"('A', 'B', 'sort', 'output', 'overwrite_a', 'overwrite_b', 'check_finite')","(nan, nan, 'lhp', 'real', False, False, True)","(nan, nan, 'str', 'str', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(A, B, sort='lhp', output='real', overwrite_a=False, overwrite_b=False, check_finite=True)"",)"
scipy,1.1.0,scipy.linalg._solvers.qr,linalg._solvers,qr,"Python Library Documentation: function qr in module scipy.linalg.decomp_qr

qr(a, overwrite_a=False, lwork=None, mode='full', pivoting=False, check_finite=True)
    Compute QR decomposition of a matrix.
    
    Calculate the decomposition ``A = Q R`` where Q is unitary/orthogonal
    and R upper triangular.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to be decomposed
    overwrite_a : bool, optional
        Whether data in a is overwritten (may improve performance)
    lwork : int, optional
        Work array size, lwork >= a.shape[1]. If None or -1, an optimal size
        is computed.
    mode : {'full', 'r', 'economic', 'raw'}, optional
        Determines what information is to be returned: either both Q and R
        ('full', default), only R ('r') or both Q and R but computed in
        economy-size ('economic', see Notes). The final option 'raw'
        (added in Scipy 0.11) makes the function return two matrices
        (Q, TAU) in the internal format used by LAPACK.
    pivoting : bool, optional
        Whether or not factorization should include pivoting for rank-revealing
        qr decomposition. If pivoting, compute the decomposition
        ``A P = Q R`` as above, but where P is chosen such that the diagonal
        of R is non-increasing.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    Q : float or complex ndarray
        Of shape (M, M), or (M, K) for ``mode='economic'``.  Not returned
        if ``mode='r'``.
    R : float or complex ndarray
        Of shape (M, N), or (K, N) for ``mode='economic'``.  ``K = min(M, N)``.
    P : int ndarray
        Of shape (N,) for ``pivoting=True``. Not returned if
        ``pivoting=False``.
    
    Raises
    ------
    LinAlgError
        Raised if decomposition fails
    
    Notes
    -----
    This is an interface to the LAPACK routines dgeqrf, zgeqrf,
    dorgqr, zungqr, dgeqp3, and zgeqp3.
    
    If ``mode=economic``, the shapes of Q and R are (M, K) and (K, N) instead
    of (M,M) and (M,N), with ``K=min(M,N)``.
    
    Examples
    --------
    >>> from scipy import random, linalg, dot, diag, all, allclose
    >>> a = random.randn(9, 6)
    
    >>> q, r = linalg.qr(a)
    >>> allclose(a, np.dot(q, r))
    True
    >>> q.shape, r.shape
    ((9, 9), (9, 6))
    
    >>> r2 = linalg.qr(a, mode='r')
    >>> allclose(r, r2)
    True
    
    >>> q3, r3 = linalg.qr(a, mode='economic')
    >>> q3.shape, r3.shape
    ((9, 6), (6, 6))
    
    >>> q4, r4, p4 = linalg.qr(a, pivoting=True)
    >>> d = abs(diag(r4))
    >>> all(d[1:] <= d[:-1])
    True
    >>> allclose(a[:, p4], dot(q4, r4))
    True
    >>> q4.shape, r4.shape, p4.shape
    ((9, 9), (9, 6), (6,))
    
    >>> q5, r5, p5 = linalg.qr(a, mode='economic', pivoting=True)
    >>> q5.shape, r5.shape, p5.shape
    ((9, 6), (6, 6), (6,))
",function,"(""(a, overwrite_a=False, lwork=None, mode='full', pivoting=False, check_finite=True)"",)",scipy,1.1.0,scipy.linalg._solvers.qr,linalg._solvers,qr,"Python Library Documentation: function qr in module scipy.linalg.decomp_qr

qr(a, overwrite_a=False, lwork=None, mode='full', pivoting=False, check_finite=True)
    Compute QR decomposition of a matrix.
    
    Calculate the decomposition ``A = Q R`` where Q is unitary/orthogonal
    and R upper triangular.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to be decomposed
    overwrite_a : bool, optional
        Whether data in a is overwritten (may improve performance)
    lwork : int, optional
        Work array size, lwork >= a.shape[1]. If None or -1, an optimal size
        is computed.
    mode : {'full', 'r', 'economic', 'raw'}, optional
        Determines what information is to be returned: either both Q and R
        ('full', default), only R ('r') or both Q and R but computed in
        economy-size ('economic', see Notes). The final option 'raw'
        (added in Scipy 0.11) makes the function return two matrices
        (Q, TAU) in the internal format used by LAPACK.
    pivoting : bool, optional
        Whether or not factorization should include pivoting for rank-revealing
        qr decomposition. If pivoting, compute the decomposition
        ``A P = Q R`` as above, but where P is chosen such that the diagonal
        of R is non-increasing.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    Q : float or complex ndarray
        Of shape (M, M), or (M, K) for ``mode='economic'``.  Not returned
        if ``mode='r'``.
    R : float or complex ndarray
        Of shape (M, N), or (K, N) for ``mode='economic'``.  ``K = min(M, N)``.
    P : int ndarray
        Of shape (N,) for ``pivoting=True``. Not returned if
        ``pivoting=False``.
    
    Raises
    ------
    LinAlgError
        Raised if decomposition fails
    
    Notes
    -----
    This is an interface to the LAPACK routines dgeqrf, zgeqrf,
    dorgqr, zungqr, dgeqp3, and zgeqp3.
    
    If ``mode=economic``, the shapes of Q and R are (M, K) and (K, N) instead
    of (M,M) and (M,N), with ``K=min(M,N)``.
    
    Examples
    --------
    >>> from scipy import random, linalg, dot, diag, all, allclose
    >>> a = random.randn(9, 6)
    
    >>> q, r = linalg.qr(a)
    >>> allclose(a, np.dot(q, r))
    True
    >>> q.shape, r.shape
    ((9, 9), (9, 6))
    
    >>> r2 = linalg.qr(a, mode='r')
    >>> allclose(r, r2)
    True
    
    >>> q3, r3 = linalg.qr(a, mode='economic')
    >>> q3.shape, r3.shape
    ((9, 6), (6, 6))
    
    >>> q4, r4, p4 = linalg.qr(a, pivoting=True)
    >>> d = abs(diag(r4))
    >>> all(d[1:] <= d[:-1])
    True
    >>> allclose(a[:, p4], dot(q4, r4))
    True
    >>> q4.shape, r4.shape, p4.shape
    ((9, 9), (9, 6), (6,))
    
    >>> q5, r5, p5 = linalg.qr(a, mode='economic', pivoting=True)
    >>> q5.shape, r5.shape, p5.shape
    ((9, 6), (6, 6), (6,))
",function,"('a', 'overwrite_a', 'lwork', 'mode', 'pivoting', 'check_finite')","(nan, False, None, 'full', False, True)","(nan, 'bool', 'NoneType', 'str', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a, overwrite_a=False, lwork=None, mode='full', pivoting=False, check_finite=True)"",)"
scipy,1.1.0,scipy.linalg._solvers.schur,linalg._solvers,schur,"Python Library Documentation: function schur in module scipy.linalg.decomp_schur

schur(a, output='real', lwork=None, overwrite_a=False, sort=None, check_finite=True)
    Compute Schur decomposition of a matrix.
    
    The Schur decomposition is::
    
        A = Z T Z^H
    
    where Z is unitary and T is either upper-triangular, or for real
    Schur decomposition (output='real'), quasi-upper triangular.  In
    the quasi-triangular form, 2x2 blocks describing complex-valued
    eigenvalue pairs may extrude from the diagonal.
    
    Parameters
    ----------
    a : (M, M) array_like
        Matrix to decompose
    output : {'real', 'complex'}, optional
        Construct the real or complex Schur decomposition (for real matrices).
    lwork : int, optional
        Work array size. If None or -1, it is automatically computed.
    overwrite_a : bool, optional
        Whether to overwrite data in a (may improve performance).
    sort : {None, callable, 'lhp', 'rhp', 'iuc', 'ouc'}, optional
        Specifies whether the upper eigenvalues should be sorted.  A callable
        may be passed that, given a eigenvalue, returns a boolean denoting
        whether the eigenvalue should be sorted to the top-left (True).
        Alternatively, string parameters may be used::
    
            'lhp'   Left-hand plane (x.real < 0.0)
            'rhp'   Right-hand plane (x.real > 0.0)
            'iuc'   Inside the unit circle (x*x.conjugate() <= 1.0)
            'ouc'   Outside the unit circle (x*x.conjugate() > 1.0)
    
        Defaults to None (no sorting).
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    T : (M, M) ndarray
        Schur form of A. It is real-valued for the real Schur decomposition.
    Z : (M, M) ndarray
        An unitary Schur transformation matrix for A.
        It is real-valued for the real Schur decomposition.
    sdim : int
        If and only if sorting was requested, a third return value will
        contain the number of eigenvalues satisfying the sort condition.
    
    Raises
    ------
    LinAlgError
        Error raised under three conditions:
    
        1. The algorithm failed due to a failure of the QR algorithm to
           compute all eigenvalues
        2. If eigenvalue sorting was requested, the eigenvalues could not be
           reordered due to a failure to separate eigenvalues, usually because
           of poor conditioning
        3. If eigenvalue sorting was requested, roundoff errors caused the
           leading eigenvalues to no longer satisfy the sorting condition
    
    See also
    --------
    rsf2csf : Convert real Schur form to complex Schur form
    
    Examples
    --------
    >>> from scipy.linalg import schur, eigvals
    >>> A = np.array([[0, 2, 2], [0, 1, 2], [1, 0, 1]])
    >>> T, Z = schur(A)
    >>> T
    array([[ 2.65896708,  1.42440458, -1.92933439],
           [ 0.        , -0.32948354, -0.49063704],
           [ 0.        ,  1.31178921, -0.32948354]])
    >>> Z
    array([[0.72711591, -0.60156188, 0.33079564],
           [0.52839428, 0.79801892, 0.28976765],
           [0.43829436, 0.03590414, -0.89811411]])
    
    >>> T2, Z2 = schur(A, output='complex')
    >>> T2
    array([[ 2.65896708, -1.22839825+1.32378589j,  0.42590089+1.51937378j],
           [ 0.        , -0.32948354+0.80225456j, -0.59877807+0.56192146j],
           [ 0.        ,  0.                    , -0.32948354-0.80225456j]])
    >>> eigvals(T2)
    array([2.65896708, -0.32948354+0.80225456j, -0.32948354-0.80225456j])
    
    An arbitrary custom eig-sorting condition, having positive imaginary part, 
    which is satisfied by only one eigenvalue
    
    >>> T3, Z3, sdim = schur(A, output='complex', sort=lambda x: x.imag > 0)
    >>> sdim
    1
",function,"(""(a, output='real', lwork=None, overwrite_a=False, sort=None, check_finite=True)"",)",scipy,1.1.0,scipy.linalg._solvers.schur,linalg._solvers,schur,"Python Library Documentation: function schur in module scipy.linalg.decomp_schur

schur(a, output='real', lwork=None, overwrite_a=False, sort=None, check_finite=True)
    Compute Schur decomposition of a matrix.
    
    The Schur decomposition is::
    
        A = Z T Z^H
    
    where Z is unitary and T is either upper-triangular, or for real
    Schur decomposition (output='real'), quasi-upper triangular.  In
    the quasi-triangular form, 2x2 blocks describing complex-valued
    eigenvalue pairs may extrude from the diagonal.
    
    Parameters
    ----------
    a : (M, M) array_like
        Matrix to decompose
    output : {'real', 'complex'}, optional
        Construct the real or complex Schur decomposition (for real matrices).
    lwork : int, optional
        Work array size. If None or -1, it is automatically computed.
    overwrite_a : bool, optional
        Whether to overwrite data in a (may improve performance).
    sort : {None, callable, 'lhp', 'rhp', 'iuc', 'ouc'}, optional
        Specifies whether the upper eigenvalues should be sorted.  A callable
        may be passed that, given a eigenvalue, returns a boolean denoting
        whether the eigenvalue should be sorted to the top-left (True).
        Alternatively, string parameters may be used::
    
            'lhp'   Left-hand plane (x.real < 0.0)
            'rhp'   Right-hand plane (x.real > 0.0)
            'iuc'   Inside the unit circle (x*x.conjugate() <= 1.0)
            'ouc'   Outside the unit circle (x*x.conjugate() > 1.0)
    
        Defaults to None (no sorting).
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    T : (M, M) ndarray
        Schur form of A. It is real-valued for the real Schur decomposition.
    Z : (M, M) ndarray
        An unitary Schur transformation matrix for A.
        It is real-valued for the real Schur decomposition.
    sdim : int
        If and only if sorting was requested, a third return value will
        contain the number of eigenvalues satisfying the sort condition.
    
    Raises
    ------
    LinAlgError
        Error raised under three conditions:
    
        1. The algorithm failed due to a failure of the QR algorithm to
           compute all eigenvalues
        2. If eigenvalue sorting was requested, the eigenvalues could not be
           reordered due to a failure to separate eigenvalues, usually because
           of poor conditioning
        3. If eigenvalue sorting was requested, roundoff errors caused the
           leading eigenvalues to no longer satisfy the sorting condition
    
    See also
    --------
    rsf2csf : Convert real Schur form to complex Schur form
    
    Examples
    --------
    >>> from scipy.linalg import schur, eigvals
    >>> A = np.array([[0, 2, 2], [0, 1, 2], [1, 0, 1]])
    >>> T, Z = schur(A)
    >>> T
    array([[ 2.65896708,  1.42440458, -1.92933439],
           [ 0.        , -0.32948354, -0.49063704],
           [ 0.        ,  1.31178921, -0.32948354]])
    >>> Z
    array([[0.72711591, -0.60156188, 0.33079564],
           [0.52839428, 0.79801892, 0.28976765],
           [0.43829436, 0.03590414, -0.89811411]])
    
    >>> T2, Z2 = schur(A, output='complex')
    >>> T2
    array([[ 2.65896708, -1.22839825+1.32378589j,  0.42590089+1.51937378j],
           [ 0.        , -0.32948354+0.80225456j, -0.59877807+0.56192146j],
           [ 0.        ,  0.                    , -0.32948354-0.80225456j]])
    >>> eigvals(T2)
    array([2.65896708, -0.32948354+0.80225456j, -0.32948354-0.80225456j])
    
    An arbitrary custom eig-sorting condition, having positive imaginary part, 
    which is satisfied by only one eigenvalue
    
    >>> T3, Z3, sdim = schur(A, output='complex', sort=lambda x: x.imag > 0)
    >>> sdim
    1
",function,"('a', 'output', 'lwork', 'overwrite_a', 'sort', 'check_finite')","(nan, 'real', None, False, None, True)","(nan, 'str', 'NoneType', 'bool', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a, output='real', lwork=None, overwrite_a=False, sort=None, check_finite=True)"",)"
scipy,1.1.0,scipy.linalg._solvers.solve,linalg._solvers,solve,"Python Library Documentation: function solve in module scipy.linalg.basic

solve(a, b, sym_pos=False, lower=False, overwrite_a=False, overwrite_b=False, debug=None, check_finite=True, assume_a='gen', transposed=False)
    Solves the linear equation set ``a * x = b`` for the unknown ``x``
    for square ``a`` matrix.
    
    If the data matrix is known to be a particular type then supplying the
    corresponding string to ``assume_a`` key chooses the dedicated solver.
    The available options are
    
    ===================  ========
     generic matrix       'gen'
     symmetric            'sym'
     hermitian            'her'
     positive definite    'pos'
    ===================  ========
    
    If omitted, ``'gen'`` is the default structure.
    
    The datatype of the arrays define which solver is called regardless
    of the values. In other words, even when the complex array entries have
    precisely zero imaginary parts, the complex solver will be called based
    on the data type of the array.
    
    Parameters
    ----------
    a : (N, N) array_like
        Square input data
    b : (N, NRHS) array_like
        Input data for the right hand side.
    sym_pos : bool, optional
        Assume `a` is symmetric and positive definite. This key is deprecated
        and assume_a = 'pos' keyword is recommended instead. The functionality
        is the same. It will be removed in the future.
    lower : bool, optional
        If True, only the data contained in the lower triangle of `a`. Default
        is to use upper triangle. (ignored for ``'gen'``)
    overwrite_a : bool, optional
        Allow overwriting data in `a` (may enhance performance).
        Default is False.
    overwrite_b : bool, optional
        Allow overwriting data in `b` (may enhance performance).
        Default is False.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    assume_a : str, optional
        Valid entries are explained above.
    transposed: bool, optional
        If True, ``a^T x = b`` for real matrices, raises `NotImplementedError`
        for complex matrices (only for True).
    
    Returns
    -------
    x : (N, NRHS) ndarray
        The solution array.
    
    Raises
    ------
    ValueError
        If size mismatches detected or input a is not square.
    LinAlgError
        If the matrix is singular.
    LinAlgWarning
        If an ill-conditioned input a is detected.
    NotImplementedError
        If transposed is True and input a is a complex matrix.
    
    Examples
    --------
    Given `a` and `b`, solve for `x`:
    
    >>> a = np.array([[3, 2, 0], [1, -1, 0], [0, 5, 1]])
    >>> b = np.array([2, 4, -1])
    >>> from scipy import linalg
    >>> x = linalg.solve(a, b)
    >>> x
    array([ 2., -2.,  9.])
    >>> np.dot(a, x) == b
    array([ True,  True,  True], dtype=bool)
    
    Notes
    -----
    If the input b matrix is a 1D array with N elements, when supplied
    together with an NxN input a, it is assumed as a valid column vector
    despite the apparent size mismatch. This is compatible with the
    numpy.dot() behavior and the returned result is still 1D array.
    
    The generic, symmetric, hermitian and positive definite solutions are
    obtained via calling ?GESV, ?SYSV, ?HESV, and ?POSV routines of
    LAPACK respectively.
",function,"(""(a, b, sym_pos=False, lower=False, overwrite_a=False, overwrite_b=False, debug=None, check_finite=True, assume_a='gen', transposed=False)"",)",scipy,1.1.0,scipy.linalg._solvers.solve,linalg._solvers,solve,"Python Library Documentation: function solve in module scipy.linalg.basic

solve(a, b, sym_pos=False, lower=False, overwrite_a=False, overwrite_b=False, debug=None, check_finite=True, assume_a='gen', transposed=False)
    Solves the linear equation set ``a * x = b`` for the unknown ``x``
    for square ``a`` matrix.
    
    If the data matrix is known to be a particular type then supplying the
    corresponding string to ``assume_a`` key chooses the dedicated solver.
    The available options are
    
    ===================  ========
     generic matrix       'gen'
     symmetric            'sym'
     hermitian            'her'
     positive definite    'pos'
    ===================  ========
    
    If omitted, ``'gen'`` is the default structure.
    
    The datatype of the arrays define which solver is called regardless
    of the values. In other words, even when the complex array entries have
    precisely zero imaginary parts, the complex solver will be called based
    on the data type of the array.
    
    Parameters
    ----------
    a : (N, N) array_like
        Square input data
    b : (N, NRHS) array_like
        Input data for the right hand side.
    sym_pos : bool, optional
        Assume `a` is symmetric and positive definite. This key is deprecated
        and assume_a = 'pos' keyword is recommended instead. The functionality
        is the same. It will be removed in the future.
    lower : bool, optional
        If True, only the data contained in the lower triangle of `a`. Default
        is to use upper triangle. (ignored for ``'gen'``)
    overwrite_a : bool, optional
        Allow overwriting data in `a` (may enhance performance).
        Default is False.
    overwrite_b : bool, optional
        Allow overwriting data in `b` (may enhance performance).
        Default is False.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    assume_a : str, optional
        Valid entries are explained above.
    transposed: bool, optional
        If True, ``a^T x = b`` for real matrices, raises `NotImplementedError`
        for complex matrices (only for True).
    
    Returns
    -------
    x : (N, NRHS) ndarray
        The solution array.
    
    Raises
    ------
    ValueError
        If size mismatches detected or input a is not square.
    LinAlgError
        If the matrix is singular.
    LinAlgWarning
        If an ill-conditioned input a is detected.
    NotImplementedError
        If transposed is True and input a is a complex matrix.
    
    Examples
    --------
    Given `a` and `b`, solve for `x`:
    
    >>> a = np.array([[3, 2, 0], [1, -1, 0], [0, 5, 1]])
    >>> b = np.array([2, 4, -1])
    >>> from scipy import linalg
    >>> x = linalg.solve(a, b)
    >>> x
    array([ 2., -2.,  9.])
    >>> np.dot(a, x) == b
    array([ True,  True,  True], dtype=bool)
    
    Notes
    -----
    If the input b matrix is a 1D array with N elements, when supplied
    together with an NxN input a, it is assumed as a valid column vector
    despite the apparent size mismatch. This is compatible with the
    numpy.dot() behavior and the returned result is still 1D array.
    
    The generic, symmetric, hermitian and positive definite solutions are
    obtained via calling ?GESV, ?SYSV, ?HESV, and ?POSV routines of
    LAPACK respectively.
",function,"('a', 'b', 'sym_pos', 'lower', 'overwrite_a', 'overwrite_b', 'debug', 'check_finite', 'assume_a', 'transposed')","(nan, nan, False, False, False, False, None, True, 'gen', False)","(nan, nan, 'bool', 'bool', 'bool', 'bool', 'NoneType', 'bool', 'str', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a, b, sym_pos=False, lower=False, overwrite_a=False, overwrite_b=False, debug=None, check_finite=True, assume_a='gen', transposed=False)"",)"
scipy,1.1.0,scipy.linalg._solvers.solve_continuous_are,linalg._solvers,solve_continuous_are,"Python Library Documentation: function solve_continuous_are in module scipy.linalg._solvers

solve_continuous_are(a, b, q, r, e=None, s=None, balanced=True)
    Solves the continuous-time algebraic Riccati equation (CARE).
    
    The CARE is defined as
    
    .. math::
    
          X A + A^H X - X B R^{-1} B^H X + Q = 0
    
    The limitations for a solution to exist are :
    
        * All eigenvalues of :math:`A` on the right half plane, should be
          controllable.
    
        * The associated hamiltonian pencil (See Notes), should have
          eigenvalues sufficiently away from the imaginary axis.
    
    Moreover, if ``e`` or ``s`` is not precisely ``None``, then the
    generalized version of CARE
    
    .. math::
    
          E^HXA + A^HXE - (E^HXB + S) R^{-1} (B^HXE + S^H) + Q = 0
    
    is solved. When omitted, ``e`` is assumed to be the identity and ``s``
    is assumed to be the zero matrix with sizes compatible with ``a`` and
    ``b`` respectively.
    
    Parameters
    ----------
    a : (M, M) array_like
        Square matrix
    b : (M, N) array_like
        Input
    q : (M, M) array_like
        Input
    r : (N, N) array_like
        Nonsingular square matrix
    e : (M, M) array_like, optional
        Nonsingular square matrix
    s : (M, N) array_like, optional
        Input
    balanced : bool, optional
        The boolean that indicates whether a balancing step is performed
        on the data. The default is set to True.
    
    Returns
    -------
    x : (M, M) ndarray
        Solution to the continuous-time algebraic Riccati equation.
    
    Raises
    ------
    LinAlgError
        For cases where the stable subspace of the pencil could not be
        isolated. See Notes section and the references for details.
    
    See Also
    --------
    solve_discrete_are : Solves the discrete-time algebraic Riccati equation
    
    Notes
    -----
    The equation is solved by forming the extended hamiltonian matrix pencil,
    as described in [1]_, :math:`H - \lambda J` given by the block matrices ::
    
        [ A    0    B ]             [ E   0    0 ]
        [-Q  -A^H  -S ] - \lambda * [ 0  E^H   0 ]
        [ S^H B^H   R ]             [ 0   0    0 ]
    
    and using a QZ decomposition method.
    
    In this algorithm, the fail conditions are linked to the symmetry
    of the product :math:`U_2 U_1^{-1}` and condition number of
    :math:`U_1`. Here, :math:`U` is the 2m-by-m matrix that holds the
    eigenvectors spanning the stable subspace with 2m rows and partitioned
    into two m-row matrices. See [1]_ and [2]_ for more details.
    
    In order to improve the QZ decomposition accuracy, the pencil goes
    through a balancing step where the sum of absolute values of
    :math:`H` and :math:`J` entries (after removing the diagonal entries of
    the sum) is balanced following the recipe given in [3]_.
    
    .. versionadded:: 0.11.0
    
    References
    ----------
    .. [1]  P. van Dooren , ""A Generalized Eigenvalue Approach For Solving
       Riccati Equations."", SIAM Journal on Scientific and Statistical
       Computing, Vol.2(2), DOI: 10.1137/0902010
    
    .. [2] A.J. Laub, ""A Schur Method for Solving Algebraic Riccati
       Equations."", Massachusetts Institute of Technology. Laboratory for
       Information and Decision Systems. LIDS-R ; 859. Available online :
       http://hdl.handle.net/1721.1/1301
    
    .. [3] P. Benner, ""Symplectic Balancing of Hamiltonian Matrices"", 2001,
       SIAM J. Sci. Comput., 2001, Vol.22(5), DOI: 10.1137/S1064827500367993
    
    Examples
    --------
    Given `a`, `b`, `q`, and `r` solve for `x`:
    
    >>> from scipy import linalg
    >>> a = np.array([[4, 3], [-4.5, -3.5]])
    >>> b = np.array([[1], [-1]])
    >>> q = np.array([[9, 6], [6, 4.]])
    >>> r = 1
    >>> x = linalg.solve_continuous_are(a, b, q, r)
    >>> x
    array([[ 21.72792206,  14.48528137],
           [ 14.48528137,   9.65685425]])
    >>> np.allclose(a.T.dot(x) + x.dot(a)-x.dot(b).dot(b.T).dot(x), -q)
    True
",function,"('(a, b, q, r, e=None, s=None, balanced=True)',)",scipy,1.1.0,scipy.linalg._solvers.solve_continuous_are,linalg._solvers,solve_continuous_are,"Python Library Documentation: function solve_continuous_are in module scipy.linalg._solvers

solve_continuous_are(a, b, q, r, e=None, s=None, balanced=True)
    Solves the continuous-time algebraic Riccati equation (CARE).
    
    The CARE is defined as
    
    .. math::
    
          X A + A^H X - X B R^{-1} B^H X + Q = 0
    
    The limitations for a solution to exist are :
    
        * All eigenvalues of :math:`A` on the right half plane, should be
          controllable.
    
        * The associated hamiltonian pencil (See Notes), should have
          eigenvalues sufficiently away from the imaginary axis.
    
    Moreover, if ``e`` or ``s`` is not precisely ``None``, then the
    generalized version of CARE
    
    .. math::
    
          E^HXA + A^HXE - (E^HXB + S) R^{-1} (B^HXE + S^H) + Q = 0
    
    is solved. When omitted, ``e`` is assumed to be the identity and ``s``
    is assumed to be the zero matrix with sizes compatible with ``a`` and
    ``b`` respectively.
    
    Parameters
    ----------
    a : (M, M) array_like
        Square matrix
    b : (M, N) array_like
        Input
    q : (M, M) array_like
        Input
    r : (N, N) array_like
        Nonsingular square matrix
    e : (M, M) array_like, optional
        Nonsingular square matrix
    s : (M, N) array_like, optional
        Input
    balanced : bool, optional
        The boolean that indicates whether a balancing step is performed
        on the data. The default is set to True.
    
    Returns
    -------
    x : (M, M) ndarray
        Solution to the continuous-time algebraic Riccati equation.
    
    Raises
    ------
    LinAlgError
        For cases where the stable subspace of the pencil could not be
        isolated. See Notes section and the references for details.
    
    See Also
    --------
    solve_discrete_are : Solves the discrete-time algebraic Riccati equation
    
    Notes
    -----
    The equation is solved by forming the extended hamiltonian matrix pencil,
    as described in [1]_, :math:`H - \lambda J` given by the block matrices ::
    
        [ A    0    B ]             [ E   0    0 ]
        [-Q  -A^H  -S ] - \lambda * [ 0  E^H   0 ]
        [ S^H B^H   R ]             [ 0   0    0 ]
    
    and using a QZ decomposition method.
    
    In this algorithm, the fail conditions are linked to the symmetry
    of the product :math:`U_2 U_1^{-1}` and condition number of
    :math:`U_1`. Here, :math:`U` is the 2m-by-m matrix that holds the
    eigenvectors spanning the stable subspace with 2m rows and partitioned
    into two m-row matrices. See [1]_ and [2]_ for more details.
    
    In order to improve the QZ decomposition accuracy, the pencil goes
    through a balancing step where the sum of absolute values of
    :math:`H` and :math:`J` entries (after removing the diagonal entries of
    the sum) is balanced following the recipe given in [3]_.
    
    .. versionadded:: 0.11.0
    
    References
    ----------
    .. [1]  P. van Dooren , ""A Generalized Eigenvalue Approach For Solving
       Riccati Equations."", SIAM Journal on Scientific and Statistical
       Computing, Vol.2(2), DOI: 10.1137/0902010
    
    .. [2] A.J. Laub, ""A Schur Method for Solving Algebraic Riccati
       Equations."", Massachusetts Institute of Technology. Laboratory for
       Information and Decision Systems. LIDS-R ; 859. Available online :
       http://hdl.handle.net/1721.1/1301
    
    .. [3] P. Benner, ""Symplectic Balancing of Hamiltonian Matrices"", 2001,
       SIAM J. Sci. Comput., 2001, Vol.22(5), DOI: 10.1137/S1064827500367993
    
    Examples
    --------
    Given `a`, `b`, `q`, and `r` solve for `x`:
    
    >>> from scipy import linalg
    >>> a = np.array([[4, 3], [-4.5, -3.5]])
    >>> b = np.array([[1], [-1]])
    >>> q = np.array([[9, 6], [6, 4.]])
    >>> r = 1
    >>> x = linalg.solve_continuous_are(a, b, q, r)
    >>> x
    array([[ 21.72792206,  14.48528137],
           [ 14.48528137,   9.65685425]])
    >>> np.allclose(a.T.dot(x) + x.dot(a)-x.dot(b).dot(b.T).dot(x), -q)
    True
",function,"('a', 'b', 'q', 'r', 'e', 's', 'balanced')","(nan, nan, nan, nan, None, None, True)","(nan, nan, nan, nan, 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, b, q, r, e=None, s=None, balanced=True)',)"
scipy,1.1.0,scipy.linalg._solvers.solve_continuous_lyapunov,linalg._solvers,solve_continuous_lyapunov,"Python Library Documentation: function solve_continuous_lyapunov in module scipy.linalg._solvers

solve_continuous_lyapunov(a, q)
    Solves the continuous Lyapunov equation :math:`AX + XA^H = Q`.
    
    Uses the Bartels-Stewart algorithm to find :math:`X`.
    
    Parameters
    ----------
    a : array_like
        A square matrix
    
    q : array_like
        Right-hand side square matrix
    
    Returns
    -------
    x : ndarray
        Solution to the continuous Lyapunov equation
    
    See Also
    --------
    solve_discrete_lyapunov : computes the solution to the discrete-time
        Lyapunov equation
    solve_sylvester : computes the solution to the Sylvester equation
    
    Notes
    -----
    The continuous Lyapunov equation is a special form of the Sylvester
    equation, hence this solver relies on LAPACK routine ?TRSYL.
    
    .. versionadded:: 0.11.0
    
    Examples
    --------
    Given `a` and `q` solve for `x`:
    
    >>> from scipy import linalg
    >>> a = np.array([[-3, -2, 0], [-1, -1, 0], [0, -5, -1]])
    >>> b = np.array([2, 4, -1])
    >>> q = np.eye(3)
    >>> x = linalg.solve_continuous_lyapunov(a, q)
    >>> x
    array([[ -0.75  ,   0.875 ,  -3.75  ],
           [  0.875 ,  -1.375 ,   5.3125],
           [ -3.75  ,   5.3125, -27.0625]])
    >>> np.allclose(a.dot(x) + x.dot(a.T), q)
    True
",function,"('(a, q)',)",scipy,1.1.0,scipy.linalg._solvers.solve_continuous_lyapunov,linalg._solvers,solve_continuous_lyapunov,"Python Library Documentation: function solve_continuous_lyapunov in module scipy.linalg._solvers

solve_continuous_lyapunov(a, q)
    Solves the continuous Lyapunov equation :math:`AX + XA^H = Q`.
    
    Uses the Bartels-Stewart algorithm to find :math:`X`.
    
    Parameters
    ----------
    a : array_like
        A square matrix
    
    q : array_like
        Right-hand side square matrix
    
    Returns
    -------
    x : ndarray
        Solution to the continuous Lyapunov equation
    
    See Also
    --------
    solve_discrete_lyapunov : computes the solution to the discrete-time
        Lyapunov equation
    solve_sylvester : computes the solution to the Sylvester equation
    
    Notes
    -----
    The continuous Lyapunov equation is a special form of the Sylvester
    equation, hence this solver relies on LAPACK routine ?TRSYL.
    
    .. versionadded:: 0.11.0
    
    Examples
    --------
    Given `a` and `q` solve for `x`:
    
    >>> from scipy import linalg
    >>> a = np.array([[-3, -2, 0], [-1, -1, 0], [0, -5, -1]])
    >>> b = np.array([2, 4, -1])
    >>> q = np.eye(3)
    >>> x = linalg.solve_continuous_lyapunov(a, q)
    >>> x
    array([[ -0.75  ,   0.875 ,  -3.75  ],
           [  0.875 ,  -1.375 ,   5.3125],
           [ -3.75  ,   5.3125, -27.0625]])
    >>> np.allclose(a.dot(x) + x.dot(a.T), q)
    True
",function,"('a', 'q')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(a, q)',)"
scipy,1.1.0,scipy.linalg._solvers.solve_discrete_are,linalg._solvers,solve_discrete_are,"Python Library Documentation: function solve_discrete_are in module scipy.linalg._solvers

solve_discrete_are(a, b, q, r, e=None, s=None, balanced=True)
    Solves the discrete-time algebraic Riccati equation (DARE).
    
    The DARE is defined as
    
    .. math::
    
          A^HXA - X - (A^HXB) (R + B^HXB)^{-1} (B^HXA) + Q = 0
    
    The limitations for a solution to exist are :
    
        * All eigenvalues of :math:`A` outside the unit disc, should be
          controllable.
    
        * The associated symplectic pencil (See Notes), should have
          eigenvalues sufficiently away from the unit circle.
    
    Moreover, if ``e`` and ``s`` are not both precisely ``None``, then the
    generalized version of DARE
    
    .. math::
    
          A^HXA - E^HXE - (A^HXB+S) (R+B^HXB)^{-1} (B^HXA+S^H) + Q = 0
    
    is solved. When omitted, ``e`` is assumed to be the identity and ``s``
    is assumed to be the zero matrix.
    
    Parameters
    ----------
    a : (M, M) array_like
        Square matrix
    b : (M, N) array_like
        Input
    q : (M, M) array_like
        Input
    r : (N, N) array_like
        Square matrix
    e : (M, M) array_like, optional
        Nonsingular square matrix
    s : (M, N) array_like, optional
        Input
    balanced : bool
        The boolean that indicates whether a balancing step is performed
        on the data. The default is set to True.
    
    Returns
    -------
    x : (M, M) ndarray
        Solution to the discrete algebraic Riccati equation.
    
    Raises
    ------
    LinAlgError
        For cases where the stable subspace of the pencil could not be
        isolated. See Notes section and the references for details.
    
    See Also
    --------
    solve_continuous_are : Solves the continuous algebraic Riccati equation
    
    Notes
    -----
    The equation is solved by forming the extended symplectic matrix pencil,
    as described in [1]_, :math:`H - \lambda J` given by the block matrices ::
    
           [  A   0   B ]             [ E   0   B ]
           [ -Q  E^H -S ] - \lambda * [ 0  A^H  0 ]
           [ S^H  0   R ]             [ 0 -B^H  0 ]
    
    and using a QZ decomposition method.
    
    In this algorithm, the fail conditions are linked to the symmetry
    of the product :math:`U_2 U_1^{-1}` and condition number of
    :math:`U_1`. Here, :math:`U` is the 2m-by-m matrix that holds the
    eigenvectors spanning the stable subspace with 2m rows and partitioned
    into two m-row matrices. See [1]_ and [2]_ for more details.
    
    In order to improve the QZ decomposition accuracy, the pencil goes
    through a balancing step where the sum of absolute values of
    :math:`H` and :math:`J` rows/cols (after removing the diagonal entries)
    is balanced following the recipe given in [3]_. If the data has small
    numerical noise, balancing may amplify their effects and some clean up
    is required.
    
    .. versionadded:: 0.11.0
    
    References
    ----------
    .. [1]  P. van Dooren , ""A Generalized Eigenvalue Approach For Solving
       Riccati Equations."", SIAM Journal on Scientific and Statistical
       Computing, Vol.2(2), DOI: 10.1137/0902010
    
    .. [2] A.J. Laub, ""A Schur Method for Solving Algebraic Riccati
       Equations."", Massachusetts Institute of Technology. Laboratory for
       Information and Decision Systems. LIDS-R ; 859. Available online :
       http://hdl.handle.net/1721.1/1301
    
    .. [3] P. Benner, ""Symplectic Balancing of Hamiltonian Matrices"", 2001,
       SIAM J. Sci. Comput., 2001, Vol.22(5), DOI: 10.1137/S1064827500367993
    
    Examples
    --------
    Given `a`, `b`, `q`, and `r` solve for `x`:
    
    >>> from scipy import linalg as la
    >>> a = np.array([[0, 1], [0, -1]])
    >>> b = np.array([[1, 0], [2, 1]])
    >>> q = np.array([[-4, -4], [-4, 7]])
    >>> r = np.array([[9, 3], [3, 1]])
    >>> x = la.solve_discrete_are(a, b, q, r)
    >>> x
    array([[-4., -4.],
           [-4.,  7.]])
    >>> R = la.solve(r + b.T.dot(x).dot(b), b.T.dot(x).dot(a))
    >>> np.allclose(a.T.dot(x).dot(a) - x - a.T.dot(x).dot(b).dot(R), -q)
    True
",function,"('(a, b, q, r, e=None, s=None, balanced=True)',)",scipy,1.1.0,scipy.linalg._solvers.solve_discrete_are,linalg._solvers,solve_discrete_are,"Python Library Documentation: function solve_discrete_are in module scipy.linalg._solvers

solve_discrete_are(a, b, q, r, e=None, s=None, balanced=True)
    Solves the discrete-time algebraic Riccati equation (DARE).
    
    The DARE is defined as
    
    .. math::
    
          A^HXA - X - (A^HXB) (R + B^HXB)^{-1} (B^HXA) + Q = 0
    
    The limitations for a solution to exist are :
    
        * All eigenvalues of :math:`A` outside the unit disc, should be
          controllable.
    
        * The associated symplectic pencil (See Notes), should have
          eigenvalues sufficiently away from the unit circle.
    
    Moreover, if ``e`` and ``s`` are not both precisely ``None``, then the
    generalized version of DARE
    
    .. math::
    
          A^HXA - E^HXE - (A^HXB+S) (R+B^HXB)^{-1} (B^HXA+S^H) + Q = 0
    
    is solved. When omitted, ``e`` is assumed to be the identity and ``s``
    is assumed to be the zero matrix.
    
    Parameters
    ----------
    a : (M, M) array_like
        Square matrix
    b : (M, N) array_like
        Input
    q : (M, M) array_like
        Input
    r : (N, N) array_like
        Square matrix
    e : (M, M) array_like, optional
        Nonsingular square matrix
    s : (M, N) array_like, optional
        Input
    balanced : bool
        The boolean that indicates whether a balancing step is performed
        on the data. The default is set to True.
    
    Returns
    -------
    x : (M, M) ndarray
        Solution to the discrete algebraic Riccati equation.
    
    Raises
    ------
    LinAlgError
        For cases where the stable subspace of the pencil could not be
        isolated. See Notes section and the references for details.
    
    See Also
    --------
    solve_continuous_are : Solves the continuous algebraic Riccati equation
    
    Notes
    -----
    The equation is solved by forming the extended symplectic matrix pencil,
    as described in [1]_, :math:`H - \lambda J` given by the block matrices ::
    
           [  A   0   B ]             [ E   0   B ]
           [ -Q  E^H -S ] - \lambda * [ 0  A^H  0 ]
           [ S^H  0   R ]             [ 0 -B^H  0 ]
    
    and using a QZ decomposition method.
    
    In this algorithm, the fail conditions are linked to the symmetry
    of the product :math:`U_2 U_1^{-1}` and condition number of
    :math:`U_1`. Here, :math:`U` is the 2m-by-m matrix that holds the
    eigenvectors spanning the stable subspace with 2m rows and partitioned
    into two m-row matrices. See [1]_ and [2]_ for more details.
    
    In order to improve the QZ decomposition accuracy, the pencil goes
    through a balancing step where the sum of absolute values of
    :math:`H` and :math:`J` rows/cols (after removing the diagonal entries)
    is balanced following the recipe given in [3]_. If the data has small
    numerical noise, balancing may amplify their effects and some clean up
    is required.
    
    .. versionadded:: 0.11.0
    
    References
    ----------
    .. [1]  P. van Dooren , ""A Generalized Eigenvalue Approach For Solving
       Riccati Equations."", SIAM Journal on Scientific and Statistical
       Computing, Vol.2(2), DOI: 10.1137/0902010
    
    .. [2] A.J. Laub, ""A Schur Method for Solving Algebraic Riccati
       Equations."", Massachusetts Institute of Technology. Laboratory for
       Information and Decision Systems. LIDS-R ; 859. Available online :
       http://hdl.handle.net/1721.1/1301
    
    .. [3] P. Benner, ""Symplectic Balancing of Hamiltonian Matrices"", 2001,
       SIAM J. Sci. Comput., 2001, Vol.22(5), DOI: 10.1137/S1064827500367993
    
    Examples
    --------
    Given `a`, `b`, `q`, and `r` solve for `x`:
    
    >>> from scipy import linalg as la
    >>> a = np.array([[0, 1], [0, -1]])
    >>> b = np.array([[1, 0], [2, 1]])
    >>> q = np.array([[-4, -4], [-4, 7]])
    >>> r = np.array([[9, 3], [3, 1]])
    >>> x = la.solve_discrete_are(a, b, q, r)
    >>> x
    array([[-4., -4.],
           [-4.,  7.]])
    >>> R = la.solve(r + b.T.dot(x).dot(b), b.T.dot(x).dot(a))
    >>> np.allclose(a.T.dot(x).dot(a) - x - a.T.dot(x).dot(b).dot(R), -q)
    True
",function,"('a', 'b', 'q', 'r', 'e', 's', 'balanced')","(nan, nan, nan, nan, None, None, True)","(nan, nan, nan, nan, 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, b, q, r, e=None, s=None, balanced=True)',)"
scipy,1.1.0,scipy.linalg._solvers.solve_discrete_lyapunov,linalg._solvers,solve_discrete_lyapunov,"Python Library Documentation: function solve_discrete_lyapunov in module scipy.linalg._solvers

solve_discrete_lyapunov(a, q, method=None)
    Solves the discrete Lyapunov equation :math:`AXA^H - X + Q = 0`.
    
    Parameters
    ----------
    a, q : (M, M) array_like
        Square matrices corresponding to A and Q in the equation
        above respectively. Must have the same shape.
    
    method : {'direct', 'bilinear'}, optional
        Type of solver.
    
        If not given, chosen to be ``direct`` if ``M`` is less than 10 and
        ``bilinear`` otherwise.
    
    Returns
    -------
    x : ndarray
        Solution to the discrete Lyapunov equation
    
    See Also
    --------
    solve_continuous_lyapunov : computes the solution to the continuous-time
        Lyapunov equation
    
    Notes
    -----
    This section describes the available solvers that can be selected by the
    'method' parameter. The default method is *direct* if ``M`` is less than 10
    and ``bilinear`` otherwise.
    
    Method *direct* uses a direct analytical solution to the discrete Lyapunov
    equation. The algorithm is given in, for example, [1]_. However it requires
    the linear solution of a system with dimension :math:`M^2` so that
    performance degrades rapidly for even moderately sized matrices.
    
    Method *bilinear* uses a bilinear transformation to convert the discrete
    Lyapunov equation to a continuous Lyapunov equation :math:`(BX+XB'=-C)`
    where :math:`B=(A-I)(A+I)^{-1}` and
    :math:`C=2(A' + I)^{-1} Q (A + I)^{-1}`. The continuous equation can be
    efficiently solved since it is a special case of a Sylvester equation.
    The transformation algorithm is from Popov (1964) as described in [2]_.
    
    .. versionadded:: 0.11.0
    
    References
    ----------
    .. [1] Hamilton, James D. Time Series Analysis, Princeton: Princeton
       University Press, 1994.  265.  Print.
       http://doc1.lbfl.li/aca/FLMF037168.pdf
    .. [2] Gajic, Z., and M.T.J. Qureshi. 2008.
       Lyapunov Matrix Equation in System Stability and Control.
       Dover Books on Engineering Series. Dover Publications.
    
    Examples
    --------
    Given `a` and `q` solve for `x`:
    
    >>> from scipy import linalg
    >>> a = np.array([[0.2, 0.5],[0.7, -0.9]])
    >>> q = np.eye(2)
    >>> x = linalg.solve_discrete_lyapunov(a, q)
    >>> x
    array([[ 0.70872893,  1.43518822],
           [ 1.43518822, -2.4266315 ]])
    >>> np.allclose(a.dot(x).dot(a.T)-x, -q)
    True
",function,"('(a, q, method=None)',)",scipy,1.1.0,scipy.linalg._solvers.solve_discrete_lyapunov,linalg._solvers,solve_discrete_lyapunov,"Python Library Documentation: function solve_discrete_lyapunov in module scipy.linalg._solvers

solve_discrete_lyapunov(a, q, method=None)
    Solves the discrete Lyapunov equation :math:`AXA^H - X + Q = 0`.
    
    Parameters
    ----------
    a, q : (M, M) array_like
        Square matrices corresponding to A and Q in the equation
        above respectively. Must have the same shape.
    
    method : {'direct', 'bilinear'}, optional
        Type of solver.
    
        If not given, chosen to be ``direct`` if ``M`` is less than 10 and
        ``bilinear`` otherwise.
    
    Returns
    -------
    x : ndarray
        Solution to the discrete Lyapunov equation
    
    See Also
    --------
    solve_continuous_lyapunov : computes the solution to the continuous-time
        Lyapunov equation
    
    Notes
    -----
    This section describes the available solvers that can be selected by the
    'method' parameter. The default method is *direct* if ``M`` is less than 10
    and ``bilinear`` otherwise.
    
    Method *direct* uses a direct analytical solution to the discrete Lyapunov
    equation. The algorithm is given in, for example, [1]_. However it requires
    the linear solution of a system with dimension :math:`M^2` so that
    performance degrades rapidly for even moderately sized matrices.
    
    Method *bilinear* uses a bilinear transformation to convert the discrete
    Lyapunov equation to a continuous Lyapunov equation :math:`(BX+XB'=-C)`
    where :math:`B=(A-I)(A+I)^{-1}` and
    :math:`C=2(A' + I)^{-1} Q (A + I)^{-1}`. The continuous equation can be
    efficiently solved since it is a special case of a Sylvester equation.
    The transformation algorithm is from Popov (1964) as described in [2]_.
    
    .. versionadded:: 0.11.0
    
    References
    ----------
    .. [1] Hamilton, James D. Time Series Analysis, Princeton: Princeton
       University Press, 1994.  265.  Print.
       http://doc1.lbfl.li/aca/FLMF037168.pdf
    .. [2] Gajic, Z., and M.T.J. Qureshi. 2008.
       Lyapunov Matrix Equation in System Stability and Control.
       Dover Books on Engineering Series. Dover Publications.
    
    Examples
    --------
    Given `a` and `q` solve for `x`:
    
    >>> from scipy import linalg
    >>> a = np.array([[0.2, 0.5],[0.7, -0.9]])
    >>> q = np.eye(2)
    >>> x = linalg.solve_discrete_lyapunov(a, q)
    >>> x
    array([[ 0.70872893,  1.43518822],
           [ 1.43518822, -2.4266315 ]])
    >>> np.allclose(a.dot(x).dot(a.T)-x, -q)
    True
",function,"('a', 'q', 'method')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(a, q, method=None)',)"
scipy,1.1.0,scipy.linalg._solvers.solve_lyapunov,linalg._solvers,solve_continuous_lyapunov,"Python Library Documentation: function solve_continuous_lyapunov in module scipy.linalg._solvers

solve_continuous_lyapunov(a, q)
    Solves the continuous Lyapunov equation :math:`AX + XA^H = Q`.
    
    Uses the Bartels-Stewart algorithm to find :math:`X`.
    
    Parameters
    ----------
    a : array_like
        A square matrix
    
    q : array_like
        Right-hand side square matrix
    
    Returns
    -------
    x : ndarray
        Solution to the continuous Lyapunov equation
    
    See Also
    --------
    solve_discrete_lyapunov : computes the solution to the discrete-time
        Lyapunov equation
    solve_sylvester : computes the solution to the Sylvester equation
    
    Notes
    -----
    The continuous Lyapunov equation is a special form of the Sylvester
    equation, hence this solver relies on LAPACK routine ?TRSYL.
    
    .. versionadded:: 0.11.0
    
    Examples
    --------
    Given `a` and `q` solve for `x`:
    
    >>> from scipy import linalg
    >>> a = np.array([[-3, -2, 0], [-1, -1, 0], [0, -5, -1]])
    >>> b = np.array([2, 4, -1])
    >>> q = np.eye(3)
    >>> x = linalg.solve_continuous_lyapunov(a, q)
    >>> x
    array([[ -0.75  ,   0.875 ,  -3.75  ],
           [  0.875 ,  -1.375 ,   5.3125],
           [ -3.75  ,   5.3125, -27.0625]])
    >>> np.allclose(a.dot(x) + x.dot(a.T), q)
    True
",function,"('(a, q)',)",scipy,1.1.0,scipy.linalg._solvers.solve_lyapunov,linalg._solvers,solve_continuous_lyapunov,"Python Library Documentation: function solve_continuous_lyapunov in module scipy.linalg._solvers

solve_continuous_lyapunov(a, q)
    Solves the continuous Lyapunov equation :math:`AX + XA^H = Q`.
    
    Uses the Bartels-Stewart algorithm to find :math:`X`.
    
    Parameters
    ----------
    a : array_like
        A square matrix
    
    q : array_like
        Right-hand side square matrix
    
    Returns
    -------
    x : ndarray
        Solution to the continuous Lyapunov equation
    
    See Also
    --------
    solve_discrete_lyapunov : computes the solution to the discrete-time
        Lyapunov equation
    solve_sylvester : computes the solution to the Sylvester equation
    
    Notes
    -----
    The continuous Lyapunov equation is a special form of the Sylvester
    equation, hence this solver relies on LAPACK routine ?TRSYL.
    
    .. versionadded:: 0.11.0
    
    Examples
    --------
    Given `a` and `q` solve for `x`:
    
    >>> from scipy import linalg
    >>> a = np.array([[-3, -2, 0], [-1, -1, 0], [0, -5, -1]])
    >>> b = np.array([2, 4, -1])
    >>> q = np.eye(3)
    >>> x = linalg.solve_continuous_lyapunov(a, q)
    >>> x
    array([[ -0.75  ,   0.875 ,  -3.75  ],
           [  0.875 ,  -1.375 ,   5.3125],
           [ -3.75  ,   5.3125, -27.0625]])
    >>> np.allclose(a.dot(x) + x.dot(a.T), q)
    True
",function,"('a', 'q')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(a, q)',)"
scipy,1.1.0,scipy.linalg._solvers.solve_sylvester,linalg._solvers,solve_sylvester,"Python Library Documentation: function solve_sylvester in module scipy.linalg._solvers

solve_sylvester(a, b, q)
    Computes a solution (X) to the Sylvester equation :math:`AX + XB = Q`.
    
    Parameters
    ----------
    a : (M, M) array_like
        Leading matrix of the Sylvester equation
    b : (N, N) array_like
        Trailing matrix of the Sylvester equation
    q : (M, N) array_like
        Right-hand side
    
    Returns
    -------
    x : (M, N) ndarray
        The solution to the Sylvester equation.
    
    Raises
    ------
    LinAlgError
        If solution was not found
    
    Notes
    -----
    Computes a solution to the Sylvester matrix equation via the Bartels-
    Stewart algorithm.  The A and B matrices first undergo Schur
    decompositions.  The resulting matrices are used to construct an
    alternative Sylvester equation (``RY + YS^T = F``) where the R and S
    matrices are in quasi-triangular form (or, when R, S or F are complex,
    triangular form).  The simplified equation is then solved using
    ``*TRSYL`` from LAPACK directly.
    
    .. versionadded:: 0.11.0
    
    Examples
    --------
    Given `a`, `b`, and `q` solve for `x`:
    
    >>> from scipy import linalg
    >>> a = np.array([[-3, -2, 0], [-1, -1, 3], [3, -5, -1]])
    >>> b = np.array([[1]])
    >>> q = np.array([[1],[2],[3]])
    >>> x = linalg.solve_sylvester(a, b, q)
    >>> x
    array([[ 0.0625],
           [-0.5625],
           [ 0.6875]])
    >>> np.allclose(a.dot(x) + x.dot(b), q)
    True
",function,"('(a, b, q)',)",scipy,1.1.0,scipy.linalg._solvers.solve_sylvester,linalg._solvers,solve_sylvester,"Python Library Documentation: function solve_sylvester in module scipy.linalg._solvers

solve_sylvester(a, b, q)
    Computes a solution (X) to the Sylvester equation :math:`AX + XB = Q`.
    
    Parameters
    ----------
    a : (M, M) array_like
        Leading matrix of the Sylvester equation
    b : (N, N) array_like
        Trailing matrix of the Sylvester equation
    q : (M, N) array_like
        Right-hand side
    
    Returns
    -------
    x : (M, N) ndarray
        The solution to the Sylvester equation.
    
    Raises
    ------
    LinAlgError
        If solution was not found
    
    Notes
    -----
    Computes a solution to the Sylvester matrix equation via the Bartels-
    Stewart algorithm.  The A and B matrices first undergo Schur
    decompositions.  The resulting matrices are used to construct an
    alternative Sylvester equation (``RY + YS^T = F``) where the R and S
    matrices are in quasi-triangular form (or, when R, S or F are complex,
    triangular form).  The simplified equation is then solved using
    ``*TRSYL`` from LAPACK directly.
    
    .. versionadded:: 0.11.0
    
    Examples
    --------
    Given `a`, `b`, and `q` solve for `x`:
    
    >>> from scipy import linalg
    >>> a = np.array([[-3, -2, 0], [-1, -1, 3], [3, -5, -1]])
    >>> b = np.array([[1]])
    >>> q = np.array([[1],[2],[3]])
    >>> x = linalg.solve_sylvester(a, b, q)
    >>> x
    array([[ 0.0625],
           [-0.5625],
           [ 0.6875]])
    >>> np.allclose(a.dot(x) + x.dot(b), q)
    True
",function,"('a', 'b', 'q')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(a, b, q)',)"
scipy,1.1.0,scipy.linalg._solvers.solve_triangular,linalg._solvers,solve_triangular,"Python Library Documentation: function solve_triangular in module scipy.linalg.basic

solve_triangular(a, b, trans=0, lower=False, unit_diagonal=False, overwrite_b=False, debug=None, check_finite=True)
    Solve the equation `a x = b` for `x`, assuming a is a triangular matrix.
    
    Parameters
    ----------
    a : (M, M) array_like
        A triangular matrix
    b : (M,) or (M, N) array_like
        Right-hand side matrix in `a x = b`
    lower : bool, optional
        Use only data contained in the lower triangle of `a`.
        Default is to use upper triangle.
    trans : {0, 1, 2, 'N', 'T', 'C'}, optional
        Type of system to solve:
    
        ========  =========
        trans     system
        ========  =========
        0 or 'N'  a x  = b
        1 or 'T'  a^T x = b
        2 or 'C'  a^H x = b
        ========  =========
    unit_diagonal : bool, optional
        If True, diagonal elements of `a` are assumed to be 1 and
        will not be referenced.
    overwrite_b : bool, optional
        Allow overwriting data in `b` (may enhance performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : (M,) or (M, N) ndarray
        Solution to the system `a x = b`.  Shape of return matches `b`.
    
    Raises
    ------
    LinAlgError
        If `a` is singular
    
    Notes
    -----
    .. versionadded:: 0.9.0
    
    Examples
    --------
    Solve the lower triangular system a x = b, where::
    
             [3  0  0  0]       [4]
        a =  [2  1  0  0]   b = [2]
             [1  0  1  0]       [4]
             [1  1  1  1]       [2]
    
    >>> from scipy.linalg import solve_triangular
    >>> a = np.array([[3, 0, 0, 0], [2, 1, 0, 0], [1, 0, 1, 0], [1, 1, 1, 1]])
    >>> b = np.array([4, 2, 4, 2])
    >>> x = solve_triangular(a, b, lower=True)
    >>> x
    array([ 1.33333333, -0.66666667,  2.66666667, -1.33333333])
    >>> a.dot(x)  # Check the result
    array([ 4.,  2.,  4.,  2.])
",function,"('(a, b, trans=0, lower=False, unit_diagonal=False, overwrite_b=False, debug=None, check_finite=True)',)",scipy,1.1.0,scipy.linalg._solvers.solve_triangular,linalg._solvers,solve_triangular,"Python Library Documentation: function solve_triangular in module scipy.linalg.basic

solve_triangular(a, b, trans=0, lower=False, unit_diagonal=False, overwrite_b=False, debug=None, check_finite=True)
    Solve the equation `a x = b` for `x`, assuming a is a triangular matrix.
    
    Parameters
    ----------
    a : (M, M) array_like
        A triangular matrix
    b : (M,) or (M, N) array_like
        Right-hand side matrix in `a x = b`
    lower : bool, optional
        Use only data contained in the lower triangle of `a`.
        Default is to use upper triangle.
    trans : {0, 1, 2, 'N', 'T', 'C'}, optional
        Type of system to solve:
    
        ========  =========
        trans     system
        ========  =========
        0 or 'N'  a x  = b
        1 or 'T'  a^T x = b
        2 or 'C'  a^H x = b
        ========  =========
    unit_diagonal : bool, optional
        If True, diagonal elements of `a` are assumed to be 1 and
        will not be referenced.
    overwrite_b : bool, optional
        Allow overwriting data in `b` (may enhance performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : (M,) or (M, N) ndarray
        Solution to the system `a x = b`.  Shape of return matches `b`.
    
    Raises
    ------
    LinAlgError
        If `a` is singular
    
    Notes
    -----
    .. versionadded:: 0.9.0
    
    Examples
    --------
    Solve the lower triangular system a x = b, where::
    
             [3  0  0  0]       [4]
        a =  [2  1  0  0]   b = [2]
             [1  0  1  0]       [4]
             [1  1  1  1]       [2]
    
    >>> from scipy.linalg import solve_triangular
    >>> a = np.array([[3, 0, 0, 0], [2, 1, 0, 0], [1, 0, 1, 0], [1, 1, 1, 1]])
    >>> b = np.array([4, 2, 4, 2])
    >>> x = solve_triangular(a, b, lower=True)
    >>> x
    array([ 1.33333333, -0.66666667,  2.66666667, -1.33333333])
    >>> a.dot(x)  # Check the result
    array([ 4.,  2.,  4.,  2.])
",function,"('a', 'b', 'trans', 'lower', 'unit_diagonal', 'overwrite_b', 'debug', 'check_finite')","(nan, nan, 0, False, False, False, None, True)","(nan, nan, 'int', 'bool', 'bool', 'bool', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, b, trans=0, lower=False, unit_diagonal=False, overwrite_b=False, debug=None, check_finite=True)',)"
scipy,1.1.0,scipy.linalg._solvers.svd,linalg._solvers,svd,"Python Library Documentation: function svd in module numpy.linalg.linalg

svd(a, full_matrices=True, compute_uv=True)
    Singular Value Decomposition.
    
    When `a` is a 2D array, it is factorized as ``u @ np.diag(s) @ vh
    = (u * s) @ vh``, where `u` and `vh` are 2D unitary arrays and `s` is a 1D
    array of `a`'s singular values. When `a` is higher-dimensional, SVD is
    applied in stacked mode as explained below.
    
    Parameters
    ----------
    a : (..., M, N) array_like
        A real or complex array with ``a.ndim >= 2``.
    full_matrices : bool, optional
        If True (default), `u` and `vh` have the shapes ``(..., M, M)`` and
        ``(..., N, N)``, respectively.  Otherwise, the shapes are
        ``(..., M, K)`` and ``(..., K, N)``, respectively, where
        ``K = min(M, N)``.
    compute_uv : bool, optional
        Whether or not to compute `u` and `vh` in addition to `s`.  True
        by default.
    
    Returns
    -------
    u : { (..., M, M), (..., M, K) } array
        Unitary array(s). The first ``a.ndim - 2`` dimensions have the same
        size as those of the input `a`. The size of the last two dimensions
        depends on the value of `full_matrices`. Only returned when
        `compute_uv` is True.
    s : (..., K) array
        Vector(s) with the singular values, within each vector sorted in
        descending order. The first ``a.ndim - 2`` dimensions have the same
        size as those of the input `a`.
    vh : { (..., N, N), (..., K, N) } array
        Unitary array(s). The first ``a.ndim - 2`` dimensions have the same
        size as those of the input `a`. The size of the last two dimensions
        depends on the value of `full_matrices`. Only returned when
        `compute_uv` is True.
    
    Raises
    ------
    LinAlgError
        If SVD computation does not converge.
    
    Notes
    -----
    
    .. versionchanged:: 1.8.0
       Broadcasting rules apply, see the `numpy.linalg` documentation for
       details.
    
    The decomposition is performed using LAPACK routine ``_gesdd``.
    
    SVD is usually described for the factorization of a 2D matrix :math:`A`.
    The higher-dimensional case will be discussed below. In the 2D case, SVD is
    written as :math:`A = U S V^H`, where :math:`A = a`, :math:`U= u`,
    :math:`S= \mathtt{np.diag}(s)` and :math:`V^H = vh`. The 1D array `s`
    contains the singular values of `a` and `u` and `vh` are unitary. The rows
    of `vh` are the eigenvectors of :math:`A^H A` and the columns of `u` are
    the eigenvectors of :math:`A A^H`. In both cases the corresponding
    (possibly non-zero) eigenvalues are given by ``s**2``.
    
    If `a` has more than two dimensions, then broadcasting rules apply, as
    explained in :ref:`routines.linalg-broadcasting`. This means that SVD is
    working in ""stacked"" mode: it iterates over all indices of the first
    ``a.ndim - 2`` dimensions and for each combination SVD is applied to the
    last two indices. The matrix `a` can be reconstructed from the
    decomposition with either ``(u * s[..., None, :]) @ vh`` or
    ``u @ (s[..., None] * vh)``. (The ``@`` operator can be replaced by the
    function ``np.matmul`` for python versions below 3.5.)
    
    If `a` is a ``matrix`` object (as opposed to an ``ndarray``), then so are
    all the return values.
    
    Examples
    --------
    >>> a = np.random.randn(9, 6) + 1j*np.random.randn(9, 6)
    >>> b = np.random.randn(2, 7, 8, 3) + 1j*np.random.randn(2, 7, 8, 3)
    
    Reconstruction based on full SVD, 2D case:
    
    >>> u, s, vh = np.linalg.svd(a, full_matrices=True)
    >>> u.shape, s.shape, vh.shape
    ((9, 9), (6,), (6, 6))
    >>> np.allclose(a, np.dot(u[:, :6] * s, vh))
    True
    >>> smat = np.zeros((9, 6), dtype=complex)
    >>> smat[:6, :6] = np.diag(s)
    >>> np.allclose(a, np.dot(u, np.dot(smat, vh)))
    True
    
    Reconstruction based on reduced SVD, 2D case:
    
    >>> u, s, vh = np.linalg.svd(a, full_matrices=False)
    >>> u.shape, s.shape, vh.shape
    ((9, 6), (6,), (6, 6))
    >>> np.allclose(a, np.dot(u * s, vh))
    True
    >>> smat = np.diag(s)
    >>> np.allclose(a, np.dot(u, np.dot(smat, vh)))
    True
    
    Reconstruction based on full SVD, 4D case:
    
    >>> u, s, vh = np.linalg.svd(b, full_matrices=True)
    >>> u.shape, s.shape, vh.shape
    ((2, 7, 8, 8), (2, 7, 3), (2, 7, 3, 3))
    >>> np.allclose(b, np.matmul(u[..., :3] * s[..., None, :], vh))
    True
    >>> np.allclose(b, np.matmul(u[..., :3], s[..., None] * vh))
    True
    
    Reconstruction based on reduced SVD, 4D case:
    
    >>> u, s, vh = np.linalg.svd(b, full_matrices=False)
    >>> u.shape, s.shape, vh.shape
    ((2, 7, 8, 3), (2, 7, 3), (2, 7, 3, 3))
    >>> np.allclose(b, np.matmul(u * s[..., None, :], vh))
    True
    >>> np.allclose(b, np.matmul(u, s[..., None] * vh))
    True
",function,"('(a, full_matrices=True, compute_uv=True)',)",scipy,1.1.0,scipy.linalg._solvers.svd,linalg._solvers,svd,"Python Library Documentation: function svd in module numpy.linalg.linalg

svd(a, full_matrices=True, compute_uv=True)
    Singular Value Decomposition.
    
    When `a` is a 2D array, it is factorized as ``u @ np.diag(s) @ vh
    = (u * s) @ vh``, where `u` and `vh` are 2D unitary arrays and `s` is a 1D
    array of `a`'s singular values. When `a` is higher-dimensional, SVD is
    applied in stacked mode as explained below.
    
    Parameters
    ----------
    a : (..., M, N) array_like
        A real or complex array with ``a.ndim >= 2``.
    full_matrices : bool, optional
        If True (default), `u` and `vh` have the shapes ``(..., M, M)`` and
        ``(..., N, N)``, respectively.  Otherwise, the shapes are
        ``(..., M, K)`` and ``(..., K, N)``, respectively, where
        ``K = min(M, N)``.
    compute_uv : bool, optional
        Whether or not to compute `u` and `vh` in addition to `s`.  True
        by default.
    
    Returns
    -------
    u : { (..., M, M), (..., M, K) } array
        Unitary array(s). The first ``a.ndim - 2`` dimensions have the same
        size as those of the input `a`. The size of the last two dimensions
        depends on the value of `full_matrices`. Only returned when
        `compute_uv` is True.
    s : (..., K) array
        Vector(s) with the singular values, within each vector sorted in
        descending order. The first ``a.ndim - 2`` dimensions have the same
        size as those of the input `a`.
    vh : { (..., N, N), (..., K, N) } array
        Unitary array(s). The first ``a.ndim - 2`` dimensions have the same
        size as those of the input `a`. The size of the last two dimensions
        depends on the value of `full_matrices`. Only returned when
        `compute_uv` is True.
    
    Raises
    ------
    LinAlgError
        If SVD computation does not converge.
    
    Notes
    -----
    
    .. versionchanged:: 1.8.0
       Broadcasting rules apply, see the `numpy.linalg` documentation for
       details.
    
    The decomposition is performed using LAPACK routine ``_gesdd``.
    
    SVD is usually described for the factorization of a 2D matrix :math:`A`.
    The higher-dimensional case will be discussed below. In the 2D case, SVD is
    written as :math:`A = U S V^H`, where :math:`A = a`, :math:`U= u`,
    :math:`S= \mathtt{np.diag}(s)` and :math:`V^H = vh`. The 1D array `s`
    contains the singular values of `a` and `u` and `vh` are unitary. The rows
    of `vh` are the eigenvectors of :math:`A^H A` and the columns of `u` are
    the eigenvectors of :math:`A A^H`. In both cases the corresponding
    (possibly non-zero) eigenvalues are given by ``s**2``.
    
    If `a` has more than two dimensions, then broadcasting rules apply, as
    explained in :ref:`routines.linalg-broadcasting`. This means that SVD is
    working in ""stacked"" mode: it iterates over all indices of the first
    ``a.ndim - 2`` dimensions and for each combination SVD is applied to the
    last two indices. The matrix `a` can be reconstructed from the
    decomposition with either ``(u * s[..., None, :]) @ vh`` or
    ``u @ (s[..., None] * vh)``. (The ``@`` operator can be replaced by the
    function ``np.matmul`` for python versions below 3.5.)
    
    If `a` is a ``matrix`` object (as opposed to an ``ndarray``), then so are
    all the return values.
    
    Examples
    --------
    >>> a = np.random.randn(9, 6) + 1j*np.random.randn(9, 6)
    >>> b = np.random.randn(2, 7, 8, 3) + 1j*np.random.randn(2, 7, 8, 3)
    
    Reconstruction based on full SVD, 2D case:
    
    >>> u, s, vh = np.linalg.svd(a, full_matrices=True)
    >>> u.shape, s.shape, vh.shape
    ((9, 9), (6,), (6, 6))
    >>> np.allclose(a, np.dot(u[:, :6] * s, vh))
    True
    >>> smat = np.zeros((9, 6), dtype=complex)
    >>> smat[:6, :6] = np.diag(s)
    >>> np.allclose(a, np.dot(u, np.dot(smat, vh)))
    True
    
    Reconstruction based on reduced SVD, 2D case:
    
    >>> u, s, vh = np.linalg.svd(a, full_matrices=False)
    >>> u.shape, s.shape, vh.shape
    ((9, 6), (6,), (6, 6))
    >>> np.allclose(a, np.dot(u * s, vh))
    True
    >>> smat = np.diag(s)
    >>> np.allclose(a, np.dot(u, np.dot(smat, vh)))
    True
    
    Reconstruction based on full SVD, 4D case:
    
    >>> u, s, vh = np.linalg.svd(b, full_matrices=True)
    >>> u.shape, s.shape, vh.shape
    ((2, 7, 8, 8), (2, 7, 3), (2, 7, 3, 3))
    >>> np.allclose(b, np.matmul(u[..., :3] * s[..., None, :], vh))
    True
    >>> np.allclose(b, np.matmul(u[..., :3], s[..., None] * vh))
    True
    
    Reconstruction based on reduced SVD, 4D case:
    
    >>> u, s, vh = np.linalg.svd(b, full_matrices=False)
    >>> u.shape, s.shape, vh.shape
    ((2, 7, 8, 3), (2, 7, 3), (2, 7, 3, 3))
    >>> np.allclose(b, np.matmul(u * s[..., None, :], vh))
    True
    >>> np.allclose(b, np.matmul(u, s[..., None] * vh))
    True
",function,"('a', 'full_matrices', 'compute_uv')","(nan, True, True)","(nan, 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info')","('(a, full_matrices=True, compute_uv=True)',)"
scipy,1.1.0,scipy.linalg.basic.LinAlgError,linalg.basic,LinAlgError,"Python Library Documentation: class LinAlgError in module numpy.linalg.linalg

class LinAlgError(builtins.Exception)
 |  Generic Python-exception-derived object raised by linalg functions.
 |  
 |  General purpose exception class, derived from Python's exception.Exception
 |  class, programmatically raised in linalg functions when a Linear
 |  Algebra-related condition would prevent further correct execution of the
 |  function.
 |  
 |  Parameters
 |  ----------
 |  None
 |  
 |  Examples
 |  --------
 |  >>> from numpy import linalg as LA
 |  >>> LA.inv(np.zeros((2,2)))
 |  Traceback (most recent call last):
 |    File ""<stdin>"", line 1, in <module>
 |    File ""...linalg.py"", line 350,
 |      in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
 |    File ""...linalg.py"", line 249,
 |      in solve
 |      raise LinAlgError('Singular matrix')
 |  numpy.linalg.LinAlgError: Singular matrix
 |  
 |  Method resolution order:
 |      LinAlgError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg.basic.LinAlgError,linalg.basic,LinAlgError,"Python Library Documentation: class LinAlgError in module numpy.linalg.linalg

class LinAlgError(builtins.Exception)
 |  Generic Python-exception-derived object raised by linalg functions.
 |  
 |  General purpose exception class, derived from Python's exception.Exception
 |  class, programmatically raised in linalg functions when a Linear
 |  Algebra-related condition would prevent further correct execution of the
 |  function.
 |  
 |  Parameters
 |  ----------
 |  None
 |  
 |  Examples
 |  --------
 |  >>> from numpy import linalg as LA
 |  >>> LA.inv(np.zeros((2,2)))
 |  Traceback (most recent call last):
 |    File ""<stdin>"", line 1, in <module>
 |    File ""...linalg.py"", line 350,
 |      in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
 |    File ""...linalg.py"", line 249,
 |      in solve
 |      raise LinAlgError('Singular matrix')
 |  numpy.linalg.LinAlgError: Singular matrix
 |  
 |  Method resolution order:
 |      LinAlgError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg.basic.LinAlgWarning,linalg.basic,LinAlgWarning,"Python Library Documentation: class LinAlgWarning in module scipy.linalg.misc

class LinAlgWarning(builtins.RuntimeWarning)
 |  The warning emitted when a linear algebra related operation is close
 |  to fail conditions of the algorithm or loss of accuracy is expected.
 |  
 |  Method resolution order:
 |      LinAlgWarning
 |      builtins.RuntimeWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.RuntimeWarning:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg.basic.LinAlgWarning,linalg.basic,LinAlgWarning,"Python Library Documentation: class LinAlgWarning in module scipy.linalg.misc

class LinAlgWarning(builtins.RuntimeWarning)
 |  The warning emitted when a linear algebra related operation is close
 |  to fail conditions of the algorithm or loss of accuracy is expected.
 |  
 |  Method resolution order:
 |      LinAlgWarning
 |      builtins.RuntimeWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.RuntimeWarning:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg.basic.LstsqLapackError,linalg.basic,LstsqLapackError,"Python Library Documentation: class LstsqLapackError in module scipy.linalg.basic

class LstsqLapackError(numpy.linalg.linalg.LinAlgError)
 |  Generic Python-exception-derived object raised by linalg functions.
 |  
 |  General purpose exception class, derived from Python's exception.Exception
 |  class, programmatically raised in linalg functions when a Linear
 |  Algebra-related condition would prevent further correct execution of the
 |  function.
 |  
 |  Parameters
 |  ----------
 |  None
 |  
 |  Examples
 |  --------
 |  >>> from numpy import linalg as LA
 |  >>> LA.inv(np.zeros((2,2)))
 |  Traceback (most recent call last):
 |    File ""<stdin>"", line 1, in <module>
 |    File ""...linalg.py"", line 350,
 |      in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
 |    File ""...linalg.py"", line 249,
 |      in solve
 |      raise LinAlgError('Singular matrix')
 |  numpy.linalg.LinAlgError: Singular matrix
 |  
 |  Method resolution order:
 |      LstsqLapackError
 |      numpy.linalg.linalg.LinAlgError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors inherited from numpy.linalg.linalg.LinAlgError:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg.basic.LstsqLapackError,linalg.basic,LstsqLapackError,"Python Library Documentation: class LstsqLapackError in module scipy.linalg.basic

class LstsqLapackError(numpy.linalg.linalg.LinAlgError)
 |  Generic Python-exception-derived object raised by linalg functions.
 |  
 |  General purpose exception class, derived from Python's exception.Exception
 |  class, programmatically raised in linalg functions when a Linear
 |  Algebra-related condition would prevent further correct execution of the
 |  function.
 |  
 |  Parameters
 |  ----------
 |  None
 |  
 |  Examples
 |  --------
 |  >>> from numpy import linalg as LA
 |  >>> LA.inv(np.zeros((2,2)))
 |  Traceback (most recent call last):
 |    File ""<stdin>"", line 1, in <module>
 |    File ""...linalg.py"", line 350,
 |      in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
 |    File ""...linalg.py"", line 249,
 |      in solve
 |      raise LinAlgError('Singular matrix')
 |  numpy.linalg.LinAlgError: Singular matrix
 |  
 |  Method resolution order:
 |      LstsqLapackError
 |      numpy.linalg.linalg.LinAlgError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors inherited from numpy.linalg.linalg.LinAlgError:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg.basic._asarray_validated,linalg.basic,_asarray_validated,"Python Library Documentation: function _asarray_validated in module scipy._lib._util

_asarray_validated(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)
    Helper function for scipy argument validation.
    
    Many scipy linear algebra functions do support arbitrary array-like
    input arguments.  Examples of commonly unsupported inputs include
    matrices containing inf/nan, sparse matrix representations, and
    matrices with complicated elements.
    
    Parameters
    ----------
    a : array_like
        The array-like input.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default: True
    sparse_ok : bool, optional
        True if scipy sparse matrices are allowed.
    objects_ok : bool, optional
        True if arrays with dype('O') are allowed.
    mask_ok : bool, optional
        True if masked arrays are allowed.
    as_inexact : bool, optional
        True to convert the input array to a np.inexact dtype.
    
    Returns
    -------
    ret : ndarray
        The converted validated array.
",function,"('(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)',)",scipy,1.1.0,scipy.linalg.basic._asarray_validated,linalg.basic,_asarray_validated,"Python Library Documentation: function _asarray_validated in module scipy._lib._util

_asarray_validated(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)
    Helper function for scipy argument validation.
    
    Many scipy linear algebra functions do support arbitrary array-like
    input arguments.  Examples of commonly unsupported inputs include
    matrices containing inf/nan, sparse matrix representations, and
    matrices with complicated elements.
    
    Parameters
    ----------
    a : array_like
        The array-like input.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default: True
    sparse_ok : bool, optional
        True if scipy sparse matrices are allowed.
    objects_ok : bool, optional
        True if arrays with dype('O') are allowed.
    mask_ok : bool, optional
        True if masked arrays are allowed.
    as_inexact : bool, optional
        True to convert the input array to a np.inexact dtype.
    
    Returns
    -------
    ret : ndarray
        The converted validated array.
",function,"('a', 'check_finite', 'sparse_ok', 'objects_ok', 'mask_ok', 'as_inexact')","(nan, True, False, False, False, False)","(nan, 'bool', 'bool', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)',)"
scipy,1.1.0,scipy.linalg.basic._compute_lwork,linalg.basic,_compute_lwork,"Python Library Documentation: function _compute_lwork in module scipy.linalg.lapack

_compute_lwork(routine, *args, **kwargs)
    Round floating-point lwork returned by lapack to integer.
    
    Several LAPACK routines compute optimal values for LWORK, which
    they return in a floating-point variable. However, for large
    values of LWORK, single-precision floating point is not sufficient
    to hold the exact value --- some LAPACK versions (<= 3.5.0 at
    least) truncate the returned integer to single precision and in
    some cases this can be smaller than the required value.
    
    Examples
    --------
    >>> from scipy.linalg import lapack
    >>> n = 5000
    >>> s_r, s_lw = lapack.get_lapack_funcs(('sysvx', 'sysvx_lwork'))
    >>> lwork = lapack._compute_lwork(s_lw, n)
    >>> lwork
    32000
",function,"('(routine, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg.basic._compute_lwork,linalg.basic,_compute_lwork,"Python Library Documentation: function _compute_lwork in module scipy.linalg.lapack

_compute_lwork(routine, *args, **kwargs)
    Round floating-point lwork returned by lapack to integer.
    
    Several LAPACK routines compute optimal values for LWORK, which
    they return in a floating-point variable. However, for large
    values of LWORK, single-precision floating point is not sufficient
    to hold the exact value --- some LAPACK versions (<= 3.5.0 at
    least) truncate the returned integer to single precision and in
    some cases this can be smaller than the required value.
    
    Examples
    --------
    >>> from scipy.linalg import lapack
    >>> n = 5000
    >>> s_r, s_lw = lapack.get_lapack_funcs(('sysvx', 'sysvx_lwork'))
    >>> lwork = lapack._compute_lwork(s_lw, n)
    >>> lwork
    32000
",function,"('routine',)","(nan,)","(nan,)","('arg_info',)","('(routine, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg.basic._datacopied,linalg.basic,_datacopied,"Python Library Documentation: function _datacopied in module scipy.linalg.misc

_datacopied(arr, original)
    Strict check for `arr` not sharing any data with `original`,
    under the assumption that arr = asarray(original)
",function,"('(arr, original)',)",scipy,1.1.0,scipy.linalg.basic._datacopied,linalg.basic,_datacopied,"Python Library Documentation: function _datacopied in module scipy.linalg.misc

_datacopied(arr, original)
    Strict check for `arr` not sharing any data with `original`,
    under the assumption that arr = asarray(original)
",function,"('arr', 'original')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(arr, original)',)"
scipy,1.1.0,scipy.linalg.basic._get_axis_len,linalg.basic,_get_axis_len,"Python Library Documentation: function _get_axis_len in module scipy.linalg.basic

_get_axis_len(aname, a, axis)
",function,"('(aname, a, axis)',)",scipy,1.1.0,scipy.linalg.basic._get_axis_len,linalg.basic,_get_axis_len,"Python Library Documentation: function _get_axis_len in module scipy.linalg.basic

_get_axis_len(aname, a, axis)
",function,"('aname', 'a', 'axis')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(aname, a, axis)',)"
scipy,1.1.0,scipy.linalg.basic._solve_check,linalg.basic,_solve_check,"Python Library Documentation: function _solve_check in module scipy.linalg.basic

_solve_check(n, info, lamch=None, rcond=None)
    Check arguments during the different steps of the solution phase
",function,"('(n, info, lamch=None, rcond=None)',)",scipy,1.1.0,scipy.linalg.basic._solve_check,linalg.basic,_solve_check,"Python Library Documentation: function _solve_check in module scipy.linalg.basic

_solve_check(n, info, lamch=None, rcond=None)
    Check arguments during the different steps of the solution phase
",function,"('n', 'info', 'lamch', 'rcond')","(nan, nan, None, None)","(nan, nan, 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(n, info, lamch=None, rcond=None)',)"
scipy,1.1.0,scipy.linalg.basic.atleast_1d,linalg.basic,atleast_1d,"Python Library Documentation: function atleast_1d in module numpy.core.shape_base

atleast_1d(*arys)
    Convert inputs to arrays with at least one dimension.
    
    Scalar inputs are converted to 1-dimensional arrays, whilst
    higher-dimensional inputs are preserved.
    
    Parameters
    ----------
    arys1, arys2, ... : array_like
        One or more input arrays.
    
    Returns
    -------
    ret : ndarray
        An array, or list of arrays, each with ``a.ndim >= 1``.
        Copies are made only if necessary.
    
    See Also
    --------
    atleast_2d, atleast_3d
    
    Examples
    --------
    >>> np.atleast_1d(1.0)
    array([ 1.])
    
    >>> x = np.arange(9.0).reshape(3,3)
    >>> np.atleast_1d(x)
    array([[ 0.,  1.,  2.],
           [ 3.,  4.,  5.],
           [ 6.,  7.,  8.]])
    >>> np.atleast_1d(x) is x
    True
    
    >>> np.atleast_1d(1, [3, 4])
    [array([1]), array([3, 4])]
",function,"('(*arys)',)",scipy,1.1.0,scipy.linalg.basic.atleast_1d,linalg.basic,atleast_1d,"Python Library Documentation: function atleast_1d in module numpy.core.shape_base

atleast_1d(*arys)
    Convert inputs to arrays with at least one dimension.
    
    Scalar inputs are converted to 1-dimensional arrays, whilst
    higher-dimensional inputs are preserved.
    
    Parameters
    ----------
    arys1, arys2, ... : array_like
        One or more input arrays.
    
    Returns
    -------
    ret : ndarray
        An array, or list of arrays, each with ``a.ndim >= 1``.
        Copies are made only if necessary.
    
    See Also
    --------
    atleast_2d, atleast_3d
    
    Examples
    --------
    >>> np.atleast_1d(1.0)
    array([ 1.])
    
    >>> x = np.arange(9.0).reshape(3,3)
    >>> np.atleast_1d(x)
    array([[ 0.,  1.,  2.],
           [ 3.,  4.,  5.],
           [ 6.,  7.,  8.]])
    >>> np.atleast_1d(x) is x
    True
    
    >>> np.atleast_1d(1, [3, 4])
    [array([1]), array([3, 4])]
",function,(),(),(),(),"('(*arys)',)"
scipy,1.1.0,scipy.linalg.basic.atleast_2d,linalg.basic,atleast_2d,"Python Library Documentation: function atleast_2d in module numpy.core.shape_base

atleast_2d(*arys)
    View inputs as arrays with at least two dimensions.
    
    Parameters
    ----------
    arys1, arys2, ... : array_like
        One or more array-like sequences.  Non-array inputs are converted
        to arrays.  Arrays that already have two or more dimensions are
        preserved.
    
    Returns
    -------
    res, res2, ... : ndarray
        An array, or list of arrays, each with ``a.ndim >= 2``.
        Copies are avoided where possible, and views with two or more
        dimensions are returned.
    
    See Also
    --------
    atleast_1d, atleast_3d
    
    Examples
    --------
    >>> np.atleast_2d(3.0)
    array([[ 3.]])
    
    >>> x = np.arange(3.0)
    >>> np.atleast_2d(x)
    array([[ 0.,  1.,  2.]])
    >>> np.atleast_2d(x).base is x
    True
    
    >>> np.atleast_2d(1, [1, 2], [[1, 2]])
    [array([[1]]), array([[1, 2]]), array([[1, 2]])]
",function,"('(*arys)',)",scipy,1.1.0,scipy.linalg.basic.atleast_2d,linalg.basic,atleast_2d,"Python Library Documentation: function atleast_2d in module numpy.core.shape_base

atleast_2d(*arys)
    View inputs as arrays with at least two dimensions.
    
    Parameters
    ----------
    arys1, arys2, ... : array_like
        One or more array-like sequences.  Non-array inputs are converted
        to arrays.  Arrays that already have two or more dimensions are
        preserved.
    
    Returns
    -------
    res, res2, ... : ndarray
        An array, or list of arrays, each with ``a.ndim >= 2``.
        Copies are avoided where possible, and views with two or more
        dimensions are returned.
    
    See Also
    --------
    atleast_1d, atleast_3d
    
    Examples
    --------
    >>> np.atleast_2d(3.0)
    array([[ 3.]])
    
    >>> x = np.arange(3.0)
    >>> np.atleast_2d(x)
    array([[ 0.,  1.,  2.]])
    >>> np.atleast_2d(x).base is x
    True
    
    >>> np.atleast_2d(1, [1, 2], [[1, 2]])
    [array([[1]]), array([[1, 2]]), array([[1, 2]])]
",function,(),(),(),(),"('(*arys)',)"
scipy,1.1.0,scipy.linalg.basic.det,linalg.basic,det,"Python Library Documentation: function det in module scipy.linalg.basic

det(a, overwrite_a=False, check_finite=True)
    Compute the determinant of a matrix
    
    The determinant of a square matrix is a value derived arithmetically
    from the coefficients of the matrix.
    
    The determinant for a 3x3 matrix, for example, is computed as follows::
    
        a    b    c
        d    e    f = A
        g    h    i
    
        det(A) = a*e*i + b*f*g + c*d*h - c*e*g - b*d*i - a*f*h
    
    Parameters
    ----------
    a : (M, M) array_like
        A square matrix.
    overwrite_a : bool, optional
        Allow overwriting data in a (may enhance performance).
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    det : float or complex
        Determinant of `a`.
    
    Notes
    -----
    The determinant is computed via LU factorization, LAPACK routine z/dgetrf.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.array([[1,2,3], [4,5,6], [7,8,9]])
    >>> linalg.det(a)
    0.0
    >>> a = np.array([[0,2,3], [4,5,6], [7,8,9]])
    >>> linalg.det(a)
    3.0
",function,"('(a, overwrite_a=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.basic.det,linalg.basic,det,"Python Library Documentation: function det in module scipy.linalg.basic

det(a, overwrite_a=False, check_finite=True)
    Compute the determinant of a matrix
    
    The determinant of a square matrix is a value derived arithmetically
    from the coefficients of the matrix.
    
    The determinant for a 3x3 matrix, for example, is computed as follows::
    
        a    b    c
        d    e    f = A
        g    h    i
    
        det(A) = a*e*i + b*f*g + c*d*h - c*e*g - b*d*i - a*f*h
    
    Parameters
    ----------
    a : (M, M) array_like
        A square matrix.
    overwrite_a : bool, optional
        Allow overwriting data in a (may enhance performance).
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    det : float or complex
        Determinant of `a`.
    
    Notes
    -----
    The determinant is computed via LU factorization, LAPACK routine z/dgetrf.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.array([[1,2,3], [4,5,6], [7,8,9]])
    >>> linalg.det(a)
    0.0
    >>> a = np.array([[0,2,3], [4,5,6], [7,8,9]])
    >>> linalg.det(a)
    3.0
",function,"('a', 'overwrite_a', 'check_finite')","(nan, False, True)","(nan, 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info')","('(a, overwrite_a=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.basic.get_flinalg_funcs,linalg.basic,get_flinalg_funcs,"Python Library Documentation: function get_flinalg_funcs in module scipy.linalg.flinalg

get_flinalg_funcs(names, arrays=(), debug=0)
    Return optimal available _flinalg function objects with
    names. arrays are used to determine optimal prefix.
",function,"('(names, arrays=(), debug=0)',)",scipy,1.1.0,scipy.linalg.basic.get_flinalg_funcs,linalg.basic,get_flinalg_funcs,"Python Library Documentation: function get_flinalg_funcs in module scipy.linalg.flinalg

get_flinalg_funcs(names, arrays=(), debug=0)
    Return optimal available _flinalg function objects with
    names. arrays are used to determine optimal prefix.
",function,"('names', 'arrays', 'debug')","(nan, (), 0)","(nan, 'tuple', 'int')","('arg_info', 'arg_info', 'arg_info')","('(names, arrays=(), debug=0)',)"
scipy,1.1.0,scipy.linalg.basic.get_lapack_funcs,linalg.basic,get_lapack_funcs,"Python Library Documentation: function get_lapack_funcs in module scipy.linalg.lapack

get_lapack_funcs(names, arrays=(), dtype=None)
    Return available LAPACK function objects from names.
    
    Arrays are used to determine the optimal prefix of LAPACK routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of LAPACK functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of LAPACK
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In LAPACK, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively, and
    are stored in attribute ``typecode`` of the returned functions.
    
    Examples
    --------
    Suppose we would like to use '?lange' routine which computes the selected
    norm of an array. We pass our array in order to get the correct 'lange'
    flavor.
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_lange = LA.get_lapack_funcs('lange', (a,))
    >>> x_lange.typecode
    'd'
    >>> x_lange = LA.get_lapack_funcs('lange',(a*1j,))
    >>> x_lange.typecode
    'z'
    
    Several LAPACK routines work best when its internal WORK array has
    the optimal size (big enough for fast computation and small enough to
    avoid waste of memory). This size is determined also by a dedicated query
    to the function which is often wrapped as a standalone function and
    commonly denoted as ``###_lwork``. Below is an example for ``?sysv``
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(1000,1000)
    >>> b = np.random.rand(1000,1)*1j
    >>> # We pick up zsysv and zsysv_lwork due to b array
    ... xsysv, xlwork = LA.get_lapack_funcs(('sysv', 'sysv_lwork'), (a, b))
    >>> opt_lwork, _ = xlwork(a.shape[0])  # returns a complex for 'z' prefix
    >>> udut, ipiv, x, info = xsysv(a, b, lwork=int(opt_lwork.real))
",function,"('(names, arrays=(), dtype=None)',)",scipy,1.1.0,scipy.linalg.basic.get_lapack_funcs,linalg.basic,get_lapack_funcs,"Python Library Documentation: function get_lapack_funcs in module scipy.linalg.lapack

get_lapack_funcs(names, arrays=(), dtype=None)
    Return available LAPACK function objects from names.
    
    Arrays are used to determine the optimal prefix of LAPACK routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of LAPACK functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of LAPACK
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In LAPACK, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively, and
    are stored in attribute ``typecode`` of the returned functions.
    
    Examples
    --------
    Suppose we would like to use '?lange' routine which computes the selected
    norm of an array. We pass our array in order to get the correct 'lange'
    flavor.
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_lange = LA.get_lapack_funcs('lange', (a,))
    >>> x_lange.typecode
    'd'
    >>> x_lange = LA.get_lapack_funcs('lange',(a*1j,))
    >>> x_lange.typecode
    'z'
    
    Several LAPACK routines work best when its internal WORK array has
    the optimal size (big enough for fast computation and small enough to
    avoid waste of memory). This size is determined also by a dedicated query
    to the function which is often wrapped as a standalone function and
    commonly denoted as ``###_lwork``. Below is an example for ``?sysv``
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(1000,1000)
    >>> b = np.random.rand(1000,1)*1j
    >>> # We pick up zsysv and zsysv_lwork due to b array
    ... xsysv, xlwork = LA.get_lapack_funcs(('sysv', 'sysv_lwork'), (a, b))
    >>> opt_lwork, _ = xlwork(a.shape[0])  # returns a complex for 'z' prefix
    >>> udut, ipiv, x, info = xsysv(a, b, lwork=int(opt_lwork.real))
",function,"('names', 'arrays', 'dtype')","(nan, (), None)","(nan, 'tuple', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(names, arrays=(), dtype=None)',)"
scipy,1.1.0,scipy.linalg.basic.inv,linalg.basic,inv,"Python Library Documentation: function inv in module scipy.linalg.basic

inv(a, overwrite_a=False, check_finite=True)
    Compute the inverse of a matrix.
    
    Parameters
    ----------
    a : array_like
        Square matrix to be inverted.
    overwrite_a : bool, optional
        Discard data in `a` (may improve performance). Default is False.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    ainv : ndarray
        Inverse of the matrix `a`.
    
    Raises
    ------
    LinAlgError
        If `a` is singular.
    ValueError
        If `a` is not square, or not 2-dimensional.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.array([[1., 2.], [3., 4.]])
    >>> linalg.inv(a)
    array([[-2. ,  1. ],
           [ 1.5, -0.5]])
    >>> np.dot(a, linalg.inv(a))
    array([[ 1.,  0.],
           [ 0.,  1.]])
",function,"('(a, overwrite_a=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.basic.inv,linalg.basic,inv,"Python Library Documentation: function inv in module scipy.linalg.basic

inv(a, overwrite_a=False, check_finite=True)
    Compute the inverse of a matrix.
    
    Parameters
    ----------
    a : array_like
        Square matrix to be inverted.
    overwrite_a : bool, optional
        Discard data in `a` (may improve performance). Default is False.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    ainv : ndarray
        Inverse of the matrix `a`.
    
    Raises
    ------
    LinAlgError
        If `a` is singular.
    ValueError
        If `a` is not square, or not 2-dimensional.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.array([[1., 2.], [3., 4.]])
    >>> linalg.inv(a)
    array([[-2. ,  1. ],
           [ 1.5, -0.5]])
    >>> np.dot(a, linalg.inv(a))
    array([[ 1.,  0.],
           [ 0.,  1.]])
",function,"('a', 'overwrite_a', 'check_finite')","(nan, False, True)","(nan, 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info')","('(a, overwrite_a=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.basic.lstsq,linalg.basic,lstsq,"Python Library Documentation: function lstsq in module scipy.linalg.basic

lstsq(a, b, cond=None, overwrite_a=False, overwrite_b=False, check_finite=True, lapack_driver=None)
    Compute least-squares solution to equation Ax = b.
    
    Compute a vector x such that the 2-norm ``|b - A x|`` is minimized.
    
    Parameters
    ----------
    a : (M, N) array_like
        Left hand side matrix (2-D array).
    b : (M,) or (M, K) array_like
        Right hand side matrix or vector (1-D or 2-D array).
    cond : float, optional
        Cutoff for 'small' singular values; used to determine effective
        rank of a. Singular values smaller than
        ``rcond * largest_singular_value`` are considered zero.
    overwrite_a : bool, optional
        Discard data in `a` (may enhance performance). Default is False.
    overwrite_b : bool, optional
        Discard data in `b` (may enhance performance). Default is False.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    lapack_driver : str, optional
        Which LAPACK driver is used to solve the least-squares problem.
        Options are ``'gelsd'``, ``'gelsy'``, ``'gelss'``. Default
        (``'gelsd'``) is a good choice.  However, ``'gelsy'`` can be slightly
        faster on many problems.  ``'gelss'`` was used historically.  It is
        generally slow but uses less memory.
    
        .. versionadded:: 0.17.0
    
    Returns
    -------
    x : (N,) or (N, K) ndarray
        Least-squares solution.  Return shape matches shape of `b`.
    residues : (0,) or () or (K,) ndarray
        Sums of residues, squared 2-norm for each column in ``b - a x``.
        If rank of matrix a is ``< N`` or ``N > M``, or ``'gelsy'`` is used,
        this is a length zero array. If b was 1-D, this is a () shape array
        (numpy scalar), otherwise the shape is (K,).
    rank : int
        Effective rank of matrix `a`.
    s : (min(M,N),) ndarray or None
        Singular values of `a`. The condition number of a is
        ``abs(s[0] / s[-1])``. None is returned when ``'gelsy'`` is used.
    
    Raises
    ------
    LinAlgError
        If computation does not converge.
    
    ValueError
        When parameters are wrong.
    
    See Also
    --------
    optimize.nnls : linear least squares with non-negativity constraint
    
    Examples
    --------
    >>> from scipy.linalg import lstsq
    >>> import matplotlib.pyplot as plt
    
    Suppose we have the following data:
    
    >>> x = np.array([1, 2.5, 3.5, 4, 5, 7, 8.5])
    >>> y = np.array([0.3, 1.1, 1.5, 2.0, 3.2, 6.6, 8.6])
    
    We want to fit a quadratic polynomial of the form ``y = a + b*x**2``
    to this data.  We first form the ""design matrix"" M, with a constant
    column of 1s and a column containing ``x**2``:
    
    >>> M = x[:, np.newaxis]**[0, 2]
    >>> M
    array([[  1.  ,   1.  ],
           [  1.  ,   6.25],
           [  1.  ,  12.25],
           [  1.  ,  16.  ],
           [  1.  ,  25.  ],
           [  1.  ,  49.  ],
           [  1.  ,  72.25]])
    
    We want to find the least-squares solution to ``M.dot(p) = y``,
    where ``p`` is a vector with length 2 that holds the parameters
    ``a`` and ``b``.
    
    >>> p, res, rnk, s = lstsq(M, y)
    >>> p
    array([ 0.20925829,  0.12013861])
    
    Plot the data and the fitted curve.
    
    >>> plt.plot(x, y, 'o', label='data')
    >>> xx = np.linspace(0, 9, 101)
    >>> yy = p[0] + p[1]*xx**2
    >>> plt.plot(xx, yy, label='least squares fit, $y = a + bx^2$')
    >>> plt.xlabel('x')
    >>> plt.ylabel('y')
    >>> plt.legend(framealpha=1, shadow=True)
    >>> plt.grid(alpha=0.25)
    >>> plt.show()
",function,"('(a, b, cond=None, overwrite_a=False, overwrite_b=False, check_finite=True, lapack_driver=None)',)",scipy,1.1.0,scipy.linalg.basic.lstsq,linalg.basic,lstsq,"Python Library Documentation: function lstsq in module scipy.linalg.basic

lstsq(a, b, cond=None, overwrite_a=False, overwrite_b=False, check_finite=True, lapack_driver=None)
    Compute least-squares solution to equation Ax = b.
    
    Compute a vector x such that the 2-norm ``|b - A x|`` is minimized.
    
    Parameters
    ----------
    a : (M, N) array_like
        Left hand side matrix (2-D array).
    b : (M,) or (M, K) array_like
        Right hand side matrix or vector (1-D or 2-D array).
    cond : float, optional
        Cutoff for 'small' singular values; used to determine effective
        rank of a. Singular values smaller than
        ``rcond * largest_singular_value`` are considered zero.
    overwrite_a : bool, optional
        Discard data in `a` (may enhance performance). Default is False.
    overwrite_b : bool, optional
        Discard data in `b` (may enhance performance). Default is False.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    lapack_driver : str, optional
        Which LAPACK driver is used to solve the least-squares problem.
        Options are ``'gelsd'``, ``'gelsy'``, ``'gelss'``. Default
        (``'gelsd'``) is a good choice.  However, ``'gelsy'`` can be slightly
        faster on many problems.  ``'gelss'`` was used historically.  It is
        generally slow but uses less memory.
    
        .. versionadded:: 0.17.0
    
    Returns
    -------
    x : (N,) or (N, K) ndarray
        Least-squares solution.  Return shape matches shape of `b`.
    residues : (0,) or () or (K,) ndarray
        Sums of residues, squared 2-norm for each column in ``b - a x``.
        If rank of matrix a is ``< N`` or ``N > M``, or ``'gelsy'`` is used,
        this is a length zero array. If b was 1-D, this is a () shape array
        (numpy scalar), otherwise the shape is (K,).
    rank : int
        Effective rank of matrix `a`.
    s : (min(M,N),) ndarray or None
        Singular values of `a`. The condition number of a is
        ``abs(s[0] / s[-1])``. None is returned when ``'gelsy'`` is used.
    
    Raises
    ------
    LinAlgError
        If computation does not converge.
    
    ValueError
        When parameters are wrong.
    
    See Also
    --------
    optimize.nnls : linear least squares with non-negativity constraint
    
    Examples
    --------
    >>> from scipy.linalg import lstsq
    >>> import matplotlib.pyplot as plt
    
    Suppose we have the following data:
    
    >>> x = np.array([1, 2.5, 3.5, 4, 5, 7, 8.5])
    >>> y = np.array([0.3, 1.1, 1.5, 2.0, 3.2, 6.6, 8.6])
    
    We want to fit a quadratic polynomial of the form ``y = a + b*x**2``
    to this data.  We first form the ""design matrix"" M, with a constant
    column of 1s and a column containing ``x**2``:
    
    >>> M = x[:, np.newaxis]**[0, 2]
    >>> M
    array([[  1.  ,   1.  ],
           [  1.  ,   6.25],
           [  1.  ,  12.25],
           [  1.  ,  16.  ],
           [  1.  ,  25.  ],
           [  1.  ,  49.  ],
           [  1.  ,  72.25]])
    
    We want to find the least-squares solution to ``M.dot(p) = y``,
    where ``p`` is a vector with length 2 that holds the parameters
    ``a`` and ``b``.
    
    >>> p, res, rnk, s = lstsq(M, y)
    >>> p
    array([ 0.20925829,  0.12013861])
    
    Plot the data and the fitted curve.
    
    >>> plt.plot(x, y, 'o', label='data')
    >>> xx = np.linspace(0, 9, 101)
    >>> yy = p[0] + p[1]*xx**2
    >>> plt.plot(xx, yy, label='least squares fit, $y = a + bx^2$')
    >>> plt.xlabel('x')
    >>> plt.ylabel('y')
    >>> plt.legend(framealpha=1, shadow=True)
    >>> plt.grid(alpha=0.25)
    >>> plt.show()
",function,"('a', 'b', 'cond', 'overwrite_a', 'overwrite_b', 'check_finite', 'lapack_driver')","(nan, nan, None, False, False, True, None)","(nan, nan, 'NoneType', 'bool', 'bool', 'bool', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, b, cond=None, overwrite_a=False, overwrite_b=False, check_finite=True, lapack_driver=None)',)"
scipy,1.1.0,scipy.linalg.basic.matrix_balance,linalg.basic,matrix_balance,"Python Library Documentation: function matrix_balance in module scipy.linalg.basic

matrix_balance(A, permute=True, scale=True, separate=False, overwrite_a=False)
    Compute a diagonal similarity transformation for row/column balancing.
    
    The balancing tries to equalize the row and column 1-norms by applying
    a similarity transformation such that the magnitude variation of the
    matrix entries is reflected to the scaling matrices.
    
    Moreover, if enabled, the matrix is first permuted to isolate the upper
    triangular parts of the matrix and, again if scaling is also enabled,
    only the remaining subblocks are subjected to scaling.
    
    The balanced matrix satisfies the following equality
    
    .. math::
    
                        B = T^{-1} A T
    
    The scaling coefficients are approximated to the nearest power of 2
    to avoid round-off errors.
    
    Parameters
    ----------
    A : (n, n) array_like
        Square data matrix for the balancing.
    permute : bool, optional
        The selector to define whether permutation of A is also performed
        prior to scaling.
    scale : bool, optional
        The selector to turn on and off the scaling. If False, the matrix
        will not be scaled.
    separate : bool, optional
        This switches from returning a full matrix of the transformation
        to a tuple of two separate 1D permutation and scaling arrays.
    overwrite_a : bool, optional
        This is passed to xGEBAL directly. Essentially, overwrites the result
        to the data. It might increase the space efficiency. See LAPACK manual
        for details. This is False by default.
    
    Returns
    -------
    B : (n, n) ndarray
        Balanced matrix
    T : (n, n) ndarray
        A possibly permuted diagonal matrix whose nonzero entries are
        integer powers of 2 to avoid numerical truncation errors.
    scale, perm : (n,) ndarray
        If ``separate`` keyword is set to True then instead of the array
        ``T`` above, the scaling and the permutation vectors are given
        separately as a tuple without allocating the full array ``T``.
    
    .. versionadded:: 0.19.0
    
    Notes
    -----
    
    This algorithm is particularly useful for eigenvalue and matrix
    decompositions and in many cases it is already called by various
    LAPACK routines.
    
    The algorithm is based on the well-known technique of [1]_ and has
    been modified to account for special cases. See [2]_ for details
    which have been implemented since LAPACK v3.5.0. Before this version
    there are corner cases where balancing can actually worsen the
    conditioning. See [3]_ for such examples.
    
    The code is a wrapper around LAPACK's xGEBAL routine family for matrix
    balancing.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> x = np.array([[1,2,0], [9,1,0.01], [1,2,10*np.pi]])
    
    >>> y, permscale = linalg.matrix_balance(x)
    >>> np.abs(x).sum(axis=0) / np.abs(x).sum(axis=1)
    array([ 3.66666667,  0.4995005 ,  0.91312162])
    
    >>> np.abs(y).sum(axis=0) / np.abs(y).sum(axis=1)
    array([ 1.2       ,  1.27041742,  0.92658316])  # may vary
    
    >>> permscale  # only powers of 2 (0.5 == 2^(-1))
    array([[  0.5,   0. ,  0. ],  # may vary
           [  0. ,   1. ,  0. ],
           [  0. ,   0. ,  1. ]])
    
    References
    ----------
    .. [1] : B.N. Parlett and C. Reinsch, ""Balancing a Matrix for
       Calculation of Eigenvalues and Eigenvectors"", Numerische Mathematik,
       Vol.13(4), 1969, DOI:10.1007/BF02165404
    
    .. [2] : R. James, J. Langou, B.R. Lowery, ""On matrix balancing and
       eigenvector computation"", 2014, Available online:
       http://arxiv.org/abs/1401.5766
    
    .. [3] :  D.S. Watkins. A case where balancing is harmful.
       Electron. Trans. Numer. Anal, Vol.23, 2006.
",function,"('(A, permute=True, scale=True, separate=False, overwrite_a=False)',)",scipy,1.1.0,scipy.linalg.basic.matrix_balance,linalg.basic,matrix_balance,"Python Library Documentation: function matrix_balance in module scipy.linalg.basic

matrix_balance(A, permute=True, scale=True, separate=False, overwrite_a=False)
    Compute a diagonal similarity transformation for row/column balancing.
    
    The balancing tries to equalize the row and column 1-norms by applying
    a similarity transformation such that the magnitude variation of the
    matrix entries is reflected to the scaling matrices.
    
    Moreover, if enabled, the matrix is first permuted to isolate the upper
    triangular parts of the matrix and, again if scaling is also enabled,
    only the remaining subblocks are subjected to scaling.
    
    The balanced matrix satisfies the following equality
    
    .. math::
    
                        B = T^{-1} A T
    
    The scaling coefficients are approximated to the nearest power of 2
    to avoid round-off errors.
    
    Parameters
    ----------
    A : (n, n) array_like
        Square data matrix for the balancing.
    permute : bool, optional
        The selector to define whether permutation of A is also performed
        prior to scaling.
    scale : bool, optional
        The selector to turn on and off the scaling. If False, the matrix
        will not be scaled.
    separate : bool, optional
        This switches from returning a full matrix of the transformation
        to a tuple of two separate 1D permutation and scaling arrays.
    overwrite_a : bool, optional
        This is passed to xGEBAL directly. Essentially, overwrites the result
        to the data. It might increase the space efficiency. See LAPACK manual
        for details. This is False by default.
    
    Returns
    -------
    B : (n, n) ndarray
        Balanced matrix
    T : (n, n) ndarray
        A possibly permuted diagonal matrix whose nonzero entries are
        integer powers of 2 to avoid numerical truncation errors.
    scale, perm : (n,) ndarray
        If ``separate`` keyword is set to True then instead of the array
        ``T`` above, the scaling and the permutation vectors are given
        separately as a tuple without allocating the full array ``T``.
    
    .. versionadded:: 0.19.0
    
    Notes
    -----
    
    This algorithm is particularly useful for eigenvalue and matrix
    decompositions and in many cases it is already called by various
    LAPACK routines.
    
    The algorithm is based on the well-known technique of [1]_ and has
    been modified to account for special cases. See [2]_ for details
    which have been implemented since LAPACK v3.5.0. Before this version
    there are corner cases where balancing can actually worsen the
    conditioning. See [3]_ for such examples.
    
    The code is a wrapper around LAPACK's xGEBAL routine family for matrix
    balancing.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> x = np.array([[1,2,0], [9,1,0.01], [1,2,10*np.pi]])
    
    >>> y, permscale = linalg.matrix_balance(x)
    >>> np.abs(x).sum(axis=0) / np.abs(x).sum(axis=1)
    array([ 3.66666667,  0.4995005 ,  0.91312162])
    
    >>> np.abs(y).sum(axis=0) / np.abs(y).sum(axis=1)
    array([ 1.2       ,  1.27041742,  0.92658316])  # may vary
    
    >>> permscale  # only powers of 2 (0.5 == 2^(-1))
    array([[  0.5,   0. ,  0. ],  # may vary
           [  0. ,   1. ,  0. ],
           [  0. ,   0. ,  1. ]])
    
    References
    ----------
    .. [1] : B.N. Parlett and C. Reinsch, ""Balancing a Matrix for
       Calculation of Eigenvalues and Eigenvectors"", Numerische Mathematik,
       Vol.13(4), 1969, DOI:10.1007/BF02165404
    
    .. [2] : R. James, J. Langou, B.R. Lowery, ""On matrix balancing and
       eigenvector computation"", 2014, Available online:
       http://arxiv.org/abs/1401.5766
    
    .. [3] :  D.S. Watkins. A case where balancing is harmful.
       Electron. Trans. Numer. Anal, Vol.23, 2006.
",function,"('A', 'permute', 'scale', 'separate', 'overwrite_a')","(nan, True, True, False, False)","(nan, 'bool', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(A, permute=True, scale=True, separate=False, overwrite_a=False)',)"
scipy,1.1.0,scipy.linalg.basic.pinv,linalg.basic,pinv,"Python Library Documentation: function pinv in module scipy.linalg.basic

pinv(a, cond=None, rcond=None, return_rank=False, check_finite=True)
    Compute the (Moore-Penrose) pseudo-inverse of a matrix.
    
    Calculate a generalized inverse of a matrix using a least-squares
    solver.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to be pseudo-inverted.
    cond, rcond : float, optional
        Cutoff for 'small' singular values in the least-squares solver.
        Singular values smaller than ``rcond * largest_singular_value``
        are considered zero.
    return_rank : bool, optional
        if True, return the effective rank of the matrix
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    B : (N, M) ndarray
        The pseudo-inverse of matrix `a`.
    rank : int
        The effective rank of the matrix.  Returned if return_rank == True
    
    Raises
    ------
    LinAlgError
        If computation does not converge.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.random.randn(9, 6)
    >>> B = linalg.pinv(a)
    >>> np.allclose(a, np.dot(a, np.dot(B, a)))
    True
    >>> np.allclose(B, np.dot(B, np.dot(a, B)))
    True
",function,"('(a, cond=None, rcond=None, return_rank=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.basic.pinv,linalg.basic,pinv,"Python Library Documentation: function pinv in module scipy.linalg.basic

pinv(a, cond=None, rcond=None, return_rank=False, check_finite=True)
    Compute the (Moore-Penrose) pseudo-inverse of a matrix.
    
    Calculate a generalized inverse of a matrix using a least-squares
    solver.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to be pseudo-inverted.
    cond, rcond : float, optional
        Cutoff for 'small' singular values in the least-squares solver.
        Singular values smaller than ``rcond * largest_singular_value``
        are considered zero.
    return_rank : bool, optional
        if True, return the effective rank of the matrix
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    B : (N, M) ndarray
        The pseudo-inverse of matrix `a`.
    rank : int
        The effective rank of the matrix.  Returned if return_rank == True
    
    Raises
    ------
    LinAlgError
        If computation does not converge.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.random.randn(9, 6)
    >>> B = linalg.pinv(a)
    >>> np.allclose(a, np.dot(a, np.dot(B, a)))
    True
    >>> np.allclose(B, np.dot(B, np.dot(a, B)))
    True
",function,"('a', 'cond', 'rcond', 'return_rank', 'check_finite')","(nan, None, None, False, True)","(nan, 'NoneType', 'NoneType', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, cond=None, rcond=None, return_rank=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.basic.pinv2,linalg.basic,pinv2,"Python Library Documentation: function pinv2 in module scipy.linalg.basic

pinv2(a, cond=None, rcond=None, return_rank=False, check_finite=True)
    Compute the (Moore-Penrose) pseudo-inverse of a matrix.
    
    Calculate a generalized inverse of a matrix using its
    singular-value decomposition and including all 'large' singular
    values.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to be pseudo-inverted.
    cond, rcond : float or None
        Cutoff for 'small' singular values.
        Singular values smaller than ``rcond*largest_singular_value``
        are considered zero.
        If None or -1, suitable machine precision is used.
    return_rank : bool, optional
        if True, return the effective rank of the matrix
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    B : (N, M) ndarray
        The pseudo-inverse of matrix `a`.
    rank : int
        The effective rank of the matrix.  Returned if return_rank == True
    
    Raises
    ------
    LinAlgError
        If SVD computation does not converge.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.random.randn(9, 6)
    >>> B = linalg.pinv2(a)
    >>> np.allclose(a, np.dot(a, np.dot(B, a)))
    True
    >>> np.allclose(B, np.dot(B, np.dot(a, B)))
    True
",function,"('(a, cond=None, rcond=None, return_rank=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.basic.pinv2,linalg.basic,pinv2,"Python Library Documentation: function pinv2 in module scipy.linalg.basic

pinv2(a, cond=None, rcond=None, return_rank=False, check_finite=True)
    Compute the (Moore-Penrose) pseudo-inverse of a matrix.
    
    Calculate a generalized inverse of a matrix using its
    singular-value decomposition and including all 'large' singular
    values.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to be pseudo-inverted.
    cond, rcond : float or None
        Cutoff for 'small' singular values.
        Singular values smaller than ``rcond*largest_singular_value``
        are considered zero.
        If None or -1, suitable machine precision is used.
    return_rank : bool, optional
        if True, return the effective rank of the matrix
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    B : (N, M) ndarray
        The pseudo-inverse of matrix `a`.
    rank : int
        The effective rank of the matrix.  Returned if return_rank == True
    
    Raises
    ------
    LinAlgError
        If SVD computation does not converge.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.random.randn(9, 6)
    >>> B = linalg.pinv2(a)
    >>> np.allclose(a, np.dot(a, np.dot(B, a)))
    True
    >>> np.allclose(B, np.dot(B, np.dot(a, B)))
    True
",function,"('a', 'cond', 'rcond', 'return_rank', 'check_finite')","(nan, None, None, False, True)","(nan, 'NoneType', 'NoneType', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, cond=None, rcond=None, return_rank=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.basic.pinvh,linalg.basic,pinvh,"Python Library Documentation: function pinvh in module scipy.linalg.basic

pinvh(a, cond=None, rcond=None, lower=True, return_rank=False, check_finite=True)
    Compute the (Moore-Penrose) pseudo-inverse of a Hermitian matrix.
    
    Calculate a generalized inverse of a Hermitian or real symmetric matrix
    using its eigenvalue decomposition and including all eigenvalues with
    'large' absolute value.
    
    Parameters
    ----------
    a : (N, N) array_like
        Real symmetric or complex hermetian matrix to be pseudo-inverted
    cond, rcond : float or None
        Cutoff for 'small' eigenvalues.
        Singular values smaller than rcond * largest_eigenvalue are considered
        zero.
    
        If None or -1, suitable machine precision is used.
    lower : bool, optional
        Whether the pertinent array data is taken from the lower or upper
        triangle of a. (Default: lower)
    return_rank : bool, optional
        if True, return the effective rank of the matrix
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    B : (N, N) ndarray
        The pseudo-inverse of matrix `a`.
    rank : int
        The effective rank of the matrix.  Returned if return_rank == True
    
    Raises
    ------
    LinAlgError
        If eigenvalue does not converge
    
    Examples
    --------
    >>> from scipy.linalg import pinvh
    >>> a = np.random.randn(9, 6)
    >>> a = np.dot(a, a.T)
    >>> B = pinvh(a)
    >>> np.allclose(a, np.dot(a, np.dot(B, a)))
    True
    >>> np.allclose(B, np.dot(B, np.dot(a, B)))
    True
",function,"('(a, cond=None, rcond=None, lower=True, return_rank=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.basic.pinvh,linalg.basic,pinvh,"Python Library Documentation: function pinvh in module scipy.linalg.basic

pinvh(a, cond=None, rcond=None, lower=True, return_rank=False, check_finite=True)
    Compute the (Moore-Penrose) pseudo-inverse of a Hermitian matrix.
    
    Calculate a generalized inverse of a Hermitian or real symmetric matrix
    using its eigenvalue decomposition and including all eigenvalues with
    'large' absolute value.
    
    Parameters
    ----------
    a : (N, N) array_like
        Real symmetric or complex hermetian matrix to be pseudo-inverted
    cond, rcond : float or None
        Cutoff for 'small' eigenvalues.
        Singular values smaller than rcond * largest_eigenvalue are considered
        zero.
    
        If None or -1, suitable machine precision is used.
    lower : bool, optional
        Whether the pertinent array data is taken from the lower or upper
        triangle of a. (Default: lower)
    return_rank : bool, optional
        if True, return the effective rank of the matrix
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    B : (N, N) ndarray
        The pseudo-inverse of matrix `a`.
    rank : int
        The effective rank of the matrix.  Returned if return_rank == True
    
    Raises
    ------
    LinAlgError
        If eigenvalue does not converge
    
    Examples
    --------
    >>> from scipy.linalg import pinvh
    >>> a = np.random.randn(9, 6)
    >>> a = np.dot(a, a.T)
    >>> B = pinvh(a)
    >>> np.allclose(a, np.dot(a, np.dot(B, a)))
    True
    >>> np.allclose(B, np.dot(B, np.dot(a, B)))
    True
",function,"('a', 'cond', 'rcond', 'lower', 'return_rank', 'check_finite')","(nan, None, None, True, False, True)","(nan, 'NoneType', 'NoneType', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, cond=None, rcond=None, lower=True, return_rank=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.basic.solve,linalg.basic,solve,"Python Library Documentation: function solve in module scipy.linalg.basic

solve(a, b, sym_pos=False, lower=False, overwrite_a=False, overwrite_b=False, debug=None, check_finite=True, assume_a='gen', transposed=False)
    Solves the linear equation set ``a * x = b`` for the unknown ``x``
    for square ``a`` matrix.
    
    If the data matrix is known to be a particular type then supplying the
    corresponding string to ``assume_a`` key chooses the dedicated solver.
    The available options are
    
    ===================  ========
     generic matrix       'gen'
     symmetric            'sym'
     hermitian            'her'
     positive definite    'pos'
    ===================  ========
    
    If omitted, ``'gen'`` is the default structure.
    
    The datatype of the arrays define which solver is called regardless
    of the values. In other words, even when the complex array entries have
    precisely zero imaginary parts, the complex solver will be called based
    on the data type of the array.
    
    Parameters
    ----------
    a : (N, N) array_like
        Square input data
    b : (N, NRHS) array_like
        Input data for the right hand side.
    sym_pos : bool, optional
        Assume `a` is symmetric and positive definite. This key is deprecated
        and assume_a = 'pos' keyword is recommended instead. The functionality
        is the same. It will be removed in the future.
    lower : bool, optional
        If True, only the data contained in the lower triangle of `a`. Default
        is to use upper triangle. (ignored for ``'gen'``)
    overwrite_a : bool, optional
        Allow overwriting data in `a` (may enhance performance).
        Default is False.
    overwrite_b : bool, optional
        Allow overwriting data in `b` (may enhance performance).
        Default is False.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    assume_a : str, optional
        Valid entries are explained above.
    transposed: bool, optional
        If True, ``a^T x = b`` for real matrices, raises `NotImplementedError`
        for complex matrices (only for True).
    
    Returns
    -------
    x : (N, NRHS) ndarray
        The solution array.
    
    Raises
    ------
    ValueError
        If size mismatches detected or input a is not square.
    LinAlgError
        If the matrix is singular.
    LinAlgWarning
        If an ill-conditioned input a is detected.
    NotImplementedError
        If transposed is True and input a is a complex matrix.
    
    Examples
    --------
    Given `a` and `b`, solve for `x`:
    
    >>> a = np.array([[3, 2, 0], [1, -1, 0], [0, 5, 1]])
    >>> b = np.array([2, 4, -1])
    >>> from scipy import linalg
    >>> x = linalg.solve(a, b)
    >>> x
    array([ 2., -2.,  9.])
    >>> np.dot(a, x) == b
    array([ True,  True,  True], dtype=bool)
    
    Notes
    -----
    If the input b matrix is a 1D array with N elements, when supplied
    together with an NxN input a, it is assumed as a valid column vector
    despite the apparent size mismatch. This is compatible with the
    numpy.dot() behavior and the returned result is still 1D array.
    
    The generic, symmetric, hermitian and positive definite solutions are
    obtained via calling ?GESV, ?SYSV, ?HESV, and ?POSV routines of
    LAPACK respectively.
",function,"(""(a, b, sym_pos=False, lower=False, overwrite_a=False, overwrite_b=False, debug=None, check_finite=True, assume_a='gen', transposed=False)"",)",scipy,1.1.0,scipy.linalg.basic.solve,linalg.basic,solve,"Python Library Documentation: function solve in module scipy.linalg.basic

solve(a, b, sym_pos=False, lower=False, overwrite_a=False, overwrite_b=False, debug=None, check_finite=True, assume_a='gen', transposed=False)
    Solves the linear equation set ``a * x = b`` for the unknown ``x``
    for square ``a`` matrix.
    
    If the data matrix is known to be a particular type then supplying the
    corresponding string to ``assume_a`` key chooses the dedicated solver.
    The available options are
    
    ===================  ========
     generic matrix       'gen'
     symmetric            'sym'
     hermitian            'her'
     positive definite    'pos'
    ===================  ========
    
    If omitted, ``'gen'`` is the default structure.
    
    The datatype of the arrays define which solver is called regardless
    of the values. In other words, even when the complex array entries have
    precisely zero imaginary parts, the complex solver will be called based
    on the data type of the array.
    
    Parameters
    ----------
    a : (N, N) array_like
        Square input data
    b : (N, NRHS) array_like
        Input data for the right hand side.
    sym_pos : bool, optional
        Assume `a` is symmetric and positive definite. This key is deprecated
        and assume_a = 'pos' keyword is recommended instead. The functionality
        is the same. It will be removed in the future.
    lower : bool, optional
        If True, only the data contained in the lower triangle of `a`. Default
        is to use upper triangle. (ignored for ``'gen'``)
    overwrite_a : bool, optional
        Allow overwriting data in `a` (may enhance performance).
        Default is False.
    overwrite_b : bool, optional
        Allow overwriting data in `b` (may enhance performance).
        Default is False.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    assume_a : str, optional
        Valid entries are explained above.
    transposed: bool, optional
        If True, ``a^T x = b`` for real matrices, raises `NotImplementedError`
        for complex matrices (only for True).
    
    Returns
    -------
    x : (N, NRHS) ndarray
        The solution array.
    
    Raises
    ------
    ValueError
        If size mismatches detected or input a is not square.
    LinAlgError
        If the matrix is singular.
    LinAlgWarning
        If an ill-conditioned input a is detected.
    NotImplementedError
        If transposed is True and input a is a complex matrix.
    
    Examples
    --------
    Given `a` and `b`, solve for `x`:
    
    >>> a = np.array([[3, 2, 0], [1, -1, 0], [0, 5, 1]])
    >>> b = np.array([2, 4, -1])
    >>> from scipy import linalg
    >>> x = linalg.solve(a, b)
    >>> x
    array([ 2., -2.,  9.])
    >>> np.dot(a, x) == b
    array([ True,  True,  True], dtype=bool)
    
    Notes
    -----
    If the input b matrix is a 1D array with N elements, when supplied
    together with an NxN input a, it is assumed as a valid column vector
    despite the apparent size mismatch. This is compatible with the
    numpy.dot() behavior and the returned result is still 1D array.
    
    The generic, symmetric, hermitian and positive definite solutions are
    obtained via calling ?GESV, ?SYSV, ?HESV, and ?POSV routines of
    LAPACK respectively.
",function,"('a', 'b', 'sym_pos', 'lower', 'overwrite_a', 'overwrite_b', 'debug', 'check_finite', 'assume_a', 'transposed')","(nan, nan, False, False, False, False, None, True, 'gen', False)","(nan, nan, 'bool', 'bool', 'bool', 'bool', 'NoneType', 'bool', 'str', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a, b, sym_pos=False, lower=False, overwrite_a=False, overwrite_b=False, debug=None, check_finite=True, assume_a='gen', transposed=False)"",)"
scipy,1.1.0,scipy.linalg.basic.solve_banded,linalg.basic,solve_banded,"Python Library Documentation: function solve_banded in module scipy.linalg.basic

solve_banded(l_and_u, ab, b, overwrite_ab=False, overwrite_b=False, debug=None, check_finite=True)
    Solve the equation a x = b for x, assuming a is banded matrix.
    
    The matrix a is stored in `ab` using the matrix diagonal ordered form::
    
        ab[u + i - j, j] == a[i,j]
    
    Example of `ab` (shape of a is (6,6), `u` =1, `l` =2)::
    
        *    a01  a12  a23  a34  a45
        a00  a11  a22  a33  a44  a55
        a10  a21  a32  a43  a54   *
        a20  a31  a42  a53   *    *
    
    Parameters
    ----------
    (l, u) : (integer, integer)
        Number of non-zero lower and upper diagonals
    ab : (`l` + `u` + 1, M) array_like
        Banded matrix
    b : (M,) or (M, K) array_like
        Right-hand side
    overwrite_ab : bool, optional
        Discard data in `ab` (may enhance performance)
    overwrite_b : bool, optional
        Discard data in `b` (may enhance performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : (M,) or (M, K) ndarray
        The solution to the system a x = b.  Returned shape depends on the
        shape of `b`.
    
    Examples
    --------
    Solve the banded system a x = b, where::
    
            [5  2 -1  0  0]       [0]
            [1  4  2 -1  0]       [1]
        a = [0  1  3  2 -1]   b = [2]
            [0  0  1  2  2]       [2]
            [0  0  0  1  1]       [3]
    
    There is one nonzero diagonal below the main diagonal (l = 1), and
    two above (u = 2).  The diagonal banded form of the matrix is::
    
             [*  * -1 -1 -1]
        ab = [*  2  2  2  2]
             [5  4  3  2  1]
             [1  1  1  1  *]
    
    >>> from scipy.linalg import solve_banded
    >>> ab = np.array([[0,  0, -1, -1, -1],
    ...                [0,  2,  2,  2,  2],
    ...                [5,  4,  3,  2,  1],
    ...                [1,  1,  1,  1,  0]])
    >>> b = np.array([0, 1, 2, 2, 3])
    >>> x = solve_banded((1, 2), ab, b)
    >>> x
    array([-2.37288136,  3.93220339, -4.        ,  4.3559322 , -1.3559322 ])
",function,"('(l_and_u, ab, b, overwrite_ab=False, overwrite_b=False, debug=None, check_finite=True)',)",scipy,1.1.0,scipy.linalg.basic.solve_banded,linalg.basic,solve_banded,"Python Library Documentation: function solve_banded in module scipy.linalg.basic

solve_banded(l_and_u, ab, b, overwrite_ab=False, overwrite_b=False, debug=None, check_finite=True)
    Solve the equation a x = b for x, assuming a is banded matrix.
    
    The matrix a is stored in `ab` using the matrix diagonal ordered form::
    
        ab[u + i - j, j] == a[i,j]
    
    Example of `ab` (shape of a is (6,6), `u` =1, `l` =2)::
    
        *    a01  a12  a23  a34  a45
        a00  a11  a22  a33  a44  a55
        a10  a21  a32  a43  a54   *
        a20  a31  a42  a53   *    *
    
    Parameters
    ----------
    (l, u) : (integer, integer)
        Number of non-zero lower and upper diagonals
    ab : (`l` + `u` + 1, M) array_like
        Banded matrix
    b : (M,) or (M, K) array_like
        Right-hand side
    overwrite_ab : bool, optional
        Discard data in `ab` (may enhance performance)
    overwrite_b : bool, optional
        Discard data in `b` (may enhance performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : (M,) or (M, K) ndarray
        The solution to the system a x = b.  Returned shape depends on the
        shape of `b`.
    
    Examples
    --------
    Solve the banded system a x = b, where::
    
            [5  2 -1  0  0]       [0]
            [1  4  2 -1  0]       [1]
        a = [0  1  3  2 -1]   b = [2]
            [0  0  1  2  2]       [2]
            [0  0  0  1  1]       [3]
    
    There is one nonzero diagonal below the main diagonal (l = 1), and
    two above (u = 2).  The diagonal banded form of the matrix is::
    
             [*  * -1 -1 -1]
        ab = [*  2  2  2  2]
             [5  4  3  2  1]
             [1  1  1  1  *]
    
    >>> from scipy.linalg import solve_banded
    >>> ab = np.array([[0,  0, -1, -1, -1],
    ...                [0,  2,  2,  2,  2],
    ...                [5,  4,  3,  2,  1],
    ...                [1,  1,  1,  1,  0]])
    >>> b = np.array([0, 1, 2, 2, 3])
    >>> x = solve_banded((1, 2), ab, b)
    >>> x
    array([-2.37288136,  3.93220339, -4.        ,  4.3559322 , -1.3559322 ])
",function,"('l_and_u', 'ab', 'b', 'overwrite_ab', 'overwrite_b', 'debug', 'check_finite')","(nan, nan, nan, False, False, None, True)","(nan, nan, nan, 'bool', 'bool', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(l_and_u, ab, b, overwrite_ab=False, overwrite_b=False, debug=None, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.basic.solve_circulant,linalg.basic,solve_circulant,"Python Library Documentation: function solve_circulant in module scipy.linalg.basic

solve_circulant(c, b, singular='raise', tol=None, caxis=-1, baxis=0, outaxis=0)
    Solve C x = b for x, where C is a circulant matrix.
    
    `C` is the circulant matrix associated with the vector `c`.
    
    The system is solved by doing division in Fourier space.  The
    calculation is::
    
        x = ifft(fft(b) / fft(c))
    
    where `fft` and `ifft` are the fast Fourier transform and its inverse,
    respectively.  For a large vector `c`, this is *much* faster than
    solving the system with the full circulant matrix.
    
    Parameters
    ----------
    c : array_like
        The coefficients of the circulant matrix.
    b : array_like
        Right-hand side matrix in ``a x = b``.
    singular : str, optional
        This argument controls how a near singular circulant matrix is
        handled.  If `singular` is ""raise"" and the circulant matrix is
        near singular, a `LinAlgError` is raised.  If `singular` is
        ""lstsq"", the least squares solution is returned.  Default is ""raise"".
    tol : float, optional
        If any eigenvalue of the circulant matrix has an absolute value
        that is less than or equal to `tol`, the matrix is considered to be
        near singular.  If not given, `tol` is set to::
    
            tol = abs_eigs.max() * abs_eigs.size * np.finfo(np.float64).eps
    
        where `abs_eigs` is the array of absolute values of the eigenvalues
        of the circulant matrix.
    caxis : int
        When `c` has dimension greater than 1, it is viewed as a collection
        of circulant vectors.  In this case, `caxis` is the axis of `c` that
        holds the vectors of circulant coefficients.
    baxis : int
        When `b` has dimension greater than 1, it is viewed as a collection
        of vectors.  In this case, `baxis` is the axis of `b` that holds the
        right-hand side vectors.
    outaxis : int
        When `c` or `b` are multidimensional, the value returned by
        `solve_circulant` is multidimensional.  In this case, `outaxis` is
        the axis of the result that holds the solution vectors.
    
    Returns
    -------
    x : ndarray
        Solution to the system ``C x = b``.
    
    Raises
    ------
    LinAlgError
        If the circulant matrix associated with `c` is near singular.
    
    See Also
    --------
    circulant : circulant matrix
    
    Notes
    -----
    For a one-dimensional vector `c` with length `m`, and an array `b`
    with shape ``(m, ...)``,
    
        solve_circulant(c, b)
    
    returns the same result as
    
        solve(circulant(c), b)
    
    where `solve` and `circulant` are from `scipy.linalg`.
    
    .. versionadded:: 0.16.0
    
    Examples
    --------
    >>> from scipy.linalg import solve_circulant, solve, circulant, lstsq
    
    >>> c = np.array([2, 2, 4])
    >>> b = np.array([1, 2, 3])
    >>> solve_circulant(c, b)
    array([ 0.75, -0.25,  0.25])
    
    Compare that result to solving the system with `scipy.linalg.solve`:
    
    >>> solve(circulant(c), b)
    array([ 0.75, -0.25,  0.25])
    
    A singular example:
    
    >>> c = np.array([1, 1, 0, 0])
    >>> b = np.array([1, 2, 3, 4])
    
    Calling ``solve_circulant(c, b)`` will raise a `LinAlgError`.  For the
    least square solution, use the option ``singular='lstsq'``:
    
    >>> solve_circulant(c, b, singular='lstsq')
    array([ 0.25,  1.25,  2.25,  1.25])
    
    Compare to `scipy.linalg.lstsq`:
    
    >>> x, resid, rnk, s = lstsq(circulant(c), b)
    >>> x
    array([ 0.25,  1.25,  2.25,  1.25])
    
    A broadcasting example:
    
    Suppose we have the vectors of two circulant matrices stored in an array
    with shape (2, 5), and three `b` vectors stored in an array with shape
    (3, 5).  For example,
    
    >>> c = np.array([[1.5, 2, 3, 0, 0], [1, 1, 4, 3, 2]])
    >>> b = np.arange(15).reshape(-1, 5)
    
    We want to solve all combinations of circulant matrices and `b` vectors,
    with the result stored in an array with shape (2, 3, 5).  When we
    disregard the axes of `c` and `b` that hold the vectors of coefficients,
    the shapes of the collections are (2,) and (3,), respectively, which are
    not compatible for broadcasting.  To have a broadcast result with shape
    (2, 3), we add a trivial dimension to `c`: ``c[:, np.newaxis, :]`` has
    shape (2, 1, 5).  The last dimension holds the coefficients of the
    circulant matrices, so when we call `solve_circulant`, we can use the
    default ``caxis=-1``.  The coefficients of the `b` vectors are in the last
    dimension of the array `b`, so we use ``baxis=-1``.  If we use the
    default `outaxis`, the result will have shape (5, 2, 3), so we'll use
    ``outaxis=-1`` to put the solution vectors in the last dimension.
    
    >>> x = solve_circulant(c[:, np.newaxis, :], b, baxis=-1, outaxis=-1)
    >>> x.shape
    (2, 3, 5)
    >>> np.set_printoptions(precision=3)  # For compact output of numbers.
    >>> x
    array([[[-0.118,  0.22 ,  1.277, -0.142,  0.302],
            [ 0.651,  0.989,  2.046,  0.627,  1.072],
            [ 1.42 ,  1.758,  2.816,  1.396,  1.841]],
           [[ 0.401,  0.304,  0.694, -0.867,  0.377],
            [ 0.856,  0.758,  1.149, -0.412,  0.831],
            [ 1.31 ,  1.213,  1.603,  0.042,  1.286]]])
    
    Check by solving one pair of `c` and `b` vectors (cf. ``x[1, 1, :]``):
    
    >>> solve_circulant(c[1], b[1, :])
    array([ 0.856,  0.758,  1.149, -0.412,  0.831])
",function,"(""(c, b, singular='raise', tol=None, caxis=-1, baxis=0, outaxis=0)"",)",scipy,1.1.0,scipy.linalg.basic.solve_circulant,linalg.basic,solve_circulant,"Python Library Documentation: function solve_circulant in module scipy.linalg.basic

solve_circulant(c, b, singular='raise', tol=None, caxis=-1, baxis=0, outaxis=0)
    Solve C x = b for x, where C is a circulant matrix.
    
    `C` is the circulant matrix associated with the vector `c`.
    
    The system is solved by doing division in Fourier space.  The
    calculation is::
    
        x = ifft(fft(b) / fft(c))
    
    where `fft` and `ifft` are the fast Fourier transform and its inverse,
    respectively.  For a large vector `c`, this is *much* faster than
    solving the system with the full circulant matrix.
    
    Parameters
    ----------
    c : array_like
        The coefficients of the circulant matrix.
    b : array_like
        Right-hand side matrix in ``a x = b``.
    singular : str, optional
        This argument controls how a near singular circulant matrix is
        handled.  If `singular` is ""raise"" and the circulant matrix is
        near singular, a `LinAlgError` is raised.  If `singular` is
        ""lstsq"", the least squares solution is returned.  Default is ""raise"".
    tol : float, optional
        If any eigenvalue of the circulant matrix has an absolute value
        that is less than or equal to `tol`, the matrix is considered to be
        near singular.  If not given, `tol` is set to::
    
            tol = abs_eigs.max() * abs_eigs.size * np.finfo(np.float64).eps
    
        where `abs_eigs` is the array of absolute values of the eigenvalues
        of the circulant matrix.
    caxis : int
        When `c` has dimension greater than 1, it is viewed as a collection
        of circulant vectors.  In this case, `caxis` is the axis of `c` that
        holds the vectors of circulant coefficients.
    baxis : int
        When `b` has dimension greater than 1, it is viewed as a collection
        of vectors.  In this case, `baxis` is the axis of `b` that holds the
        right-hand side vectors.
    outaxis : int
        When `c` or `b` are multidimensional, the value returned by
        `solve_circulant` is multidimensional.  In this case, `outaxis` is
        the axis of the result that holds the solution vectors.
    
    Returns
    -------
    x : ndarray
        Solution to the system ``C x = b``.
    
    Raises
    ------
    LinAlgError
        If the circulant matrix associated with `c` is near singular.
    
    See Also
    --------
    circulant : circulant matrix
    
    Notes
    -----
    For a one-dimensional vector `c` with length `m`, and an array `b`
    with shape ``(m, ...)``,
    
        solve_circulant(c, b)
    
    returns the same result as
    
        solve(circulant(c), b)
    
    where `solve` and `circulant` are from `scipy.linalg`.
    
    .. versionadded:: 0.16.0
    
    Examples
    --------
    >>> from scipy.linalg import solve_circulant, solve, circulant, lstsq
    
    >>> c = np.array([2, 2, 4])
    >>> b = np.array([1, 2, 3])
    >>> solve_circulant(c, b)
    array([ 0.75, -0.25,  0.25])
    
    Compare that result to solving the system with `scipy.linalg.solve`:
    
    >>> solve(circulant(c), b)
    array([ 0.75, -0.25,  0.25])
    
    A singular example:
    
    >>> c = np.array([1, 1, 0, 0])
    >>> b = np.array([1, 2, 3, 4])
    
    Calling ``solve_circulant(c, b)`` will raise a `LinAlgError`.  For the
    least square solution, use the option ``singular='lstsq'``:
    
    >>> solve_circulant(c, b, singular='lstsq')
    array([ 0.25,  1.25,  2.25,  1.25])
    
    Compare to `scipy.linalg.lstsq`:
    
    >>> x, resid, rnk, s = lstsq(circulant(c), b)
    >>> x
    array([ 0.25,  1.25,  2.25,  1.25])
    
    A broadcasting example:
    
    Suppose we have the vectors of two circulant matrices stored in an array
    with shape (2, 5), and three `b` vectors stored in an array with shape
    (3, 5).  For example,
    
    >>> c = np.array([[1.5, 2, 3, 0, 0], [1, 1, 4, 3, 2]])
    >>> b = np.arange(15).reshape(-1, 5)
    
    We want to solve all combinations of circulant matrices and `b` vectors,
    with the result stored in an array with shape (2, 3, 5).  When we
    disregard the axes of `c` and `b` that hold the vectors of coefficients,
    the shapes of the collections are (2,) and (3,), respectively, which are
    not compatible for broadcasting.  To have a broadcast result with shape
    (2, 3), we add a trivial dimension to `c`: ``c[:, np.newaxis, :]`` has
    shape (2, 1, 5).  The last dimension holds the coefficients of the
    circulant matrices, so when we call `solve_circulant`, we can use the
    default ``caxis=-1``.  The coefficients of the `b` vectors are in the last
    dimension of the array `b`, so we use ``baxis=-1``.  If we use the
    default `outaxis`, the result will have shape (5, 2, 3), so we'll use
    ``outaxis=-1`` to put the solution vectors in the last dimension.
    
    >>> x = solve_circulant(c[:, np.newaxis, :], b, baxis=-1, outaxis=-1)
    >>> x.shape
    (2, 3, 5)
    >>> np.set_printoptions(precision=3)  # For compact output of numbers.
    >>> x
    array([[[-0.118,  0.22 ,  1.277, -0.142,  0.302],
            [ 0.651,  0.989,  2.046,  0.627,  1.072],
            [ 1.42 ,  1.758,  2.816,  1.396,  1.841]],
           [[ 0.401,  0.304,  0.694, -0.867,  0.377],
            [ 0.856,  0.758,  1.149, -0.412,  0.831],
            [ 1.31 ,  1.213,  1.603,  0.042,  1.286]]])
    
    Check by solving one pair of `c` and `b` vectors (cf. ``x[1, 1, :]``):
    
    >>> solve_circulant(c[1], b[1, :])
    array([ 0.856,  0.758,  1.149, -0.412,  0.831])
",function,"('c', 'b', 'singular', 'tol', 'caxis', 'baxis', 'outaxis')","(nan, nan, 'raise', None, -1, 0, 0)","(nan, nan, nan, 'NoneType', 'int', 'int', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(c, b, singular='raise', tol=None, caxis=-1, baxis=0, outaxis=0)"",)"
scipy,1.1.0,scipy.linalg.basic.solve_toeplitz,linalg.basic,solve_toeplitz,"Python Library Documentation: function solve_toeplitz in module scipy.linalg.basic

solve_toeplitz(c_or_cr, b, check_finite=True)
    Solve a Toeplitz system using Levinson Recursion
    
    The Toeplitz matrix has constant diagonals, with c as its first column
    and r as its first row.  If r is not given, ``r == conjugate(c)`` is
    assumed.
    
    Parameters
    ----------
    c_or_cr : array_like or tuple of (array_like, array_like)
        The vector ``c``, or a tuple of arrays (``c``, ``r``). Whatever the
        actual shape of ``c``, it will be converted to a 1-D array. If not
        supplied, ``r = conjugate(c)`` is assumed; in this case, if c[0] is
        real, the Toeplitz matrix is Hermitian. r[0] is ignored; the first row
        of the Toeplitz matrix is ``[c[0], r[1:]]``.  Whatever the actual shape
        of ``r``, it will be converted to a 1-D array.
    b : (M,) or (M, K) array_like
        Right-hand side in ``T x = b``.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (result entirely NaNs) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : (M,) or (M, K) ndarray
        The solution to the system ``T x = b``.  Shape of return matches shape
        of `b`.
    
    See Also
    --------
    toeplitz : Toeplitz matrix
    
    Notes
    -----
    The solution is computed using Levinson-Durbin recursion, which is faster
    than generic least-squares methods, but can be less numerically stable.
    
    Examples
    --------
    Solve the Toeplitz system T x = b, where::
    
            [ 1 -1 -2 -3]       [1]
        T = [ 3  1 -1 -2]   b = [2]
            [ 6  3  1 -1]       [2]
            [10  6  3  1]       [5]
    
    To specify the Toeplitz matrix, only the first column and the first
    row are needed.
    
    >>> c = np.array([1, 3, 6, 10])    # First column of T
    >>> r = np.array([1, -1, -2, -3])  # First row of T
    >>> b = np.array([1, 2, 2, 5])
    
    >>> from scipy.linalg import solve_toeplitz, toeplitz
    >>> x = solve_toeplitz((c, r), b)
    >>> x
    array([ 1.66666667, -1.        , -2.66666667,  2.33333333])
    
    Check the result by creating the full Toeplitz matrix and
    multiplying it by `x`.  We should get `b`.
    
    >>> T = toeplitz(c, r)
    >>> T.dot(x)
    array([ 1.,  2.,  2.,  5.])
",function,"('(c_or_cr, b, check_finite=True)',)",scipy,1.1.0,scipy.linalg.basic.solve_toeplitz,linalg.basic,solve_toeplitz,"Python Library Documentation: function solve_toeplitz in module scipy.linalg.basic

solve_toeplitz(c_or_cr, b, check_finite=True)
    Solve a Toeplitz system using Levinson Recursion
    
    The Toeplitz matrix has constant diagonals, with c as its first column
    and r as its first row.  If r is not given, ``r == conjugate(c)`` is
    assumed.
    
    Parameters
    ----------
    c_or_cr : array_like or tuple of (array_like, array_like)
        The vector ``c``, or a tuple of arrays (``c``, ``r``). Whatever the
        actual shape of ``c``, it will be converted to a 1-D array. If not
        supplied, ``r = conjugate(c)`` is assumed; in this case, if c[0] is
        real, the Toeplitz matrix is Hermitian. r[0] is ignored; the first row
        of the Toeplitz matrix is ``[c[0], r[1:]]``.  Whatever the actual shape
        of ``r``, it will be converted to a 1-D array.
    b : (M,) or (M, K) array_like
        Right-hand side in ``T x = b``.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (result entirely NaNs) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : (M,) or (M, K) ndarray
        The solution to the system ``T x = b``.  Shape of return matches shape
        of `b`.
    
    See Also
    --------
    toeplitz : Toeplitz matrix
    
    Notes
    -----
    The solution is computed using Levinson-Durbin recursion, which is faster
    than generic least-squares methods, but can be less numerically stable.
    
    Examples
    --------
    Solve the Toeplitz system T x = b, where::
    
            [ 1 -1 -2 -3]       [1]
        T = [ 3  1 -1 -2]   b = [2]
            [ 6  3  1 -1]       [2]
            [10  6  3  1]       [5]
    
    To specify the Toeplitz matrix, only the first column and the first
    row are needed.
    
    >>> c = np.array([1, 3, 6, 10])    # First column of T
    >>> r = np.array([1, -1, -2, -3])  # First row of T
    >>> b = np.array([1, 2, 2, 5])
    
    >>> from scipy.linalg import solve_toeplitz, toeplitz
    >>> x = solve_toeplitz((c, r), b)
    >>> x
    array([ 1.66666667, -1.        , -2.66666667,  2.33333333])
    
    Check the result by creating the full Toeplitz matrix and
    multiplying it by `x`.  We should get `b`.
    
    >>> T = toeplitz(c, r)
    >>> T.dot(x)
    array([ 1.,  2.,  2.,  5.])
",function,"('c_or_cr', 'b', 'check_finite')","(nan, nan, True)","(nan, nan, 'bool')","('arg_info', 'arg_info', 'arg_info')","('(c_or_cr, b, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.basic.solve_triangular,linalg.basic,solve_triangular,"Python Library Documentation: function solve_triangular in module scipy.linalg.basic

solve_triangular(a, b, trans=0, lower=False, unit_diagonal=False, overwrite_b=False, debug=None, check_finite=True)
    Solve the equation `a x = b` for `x`, assuming a is a triangular matrix.
    
    Parameters
    ----------
    a : (M, M) array_like
        A triangular matrix
    b : (M,) or (M, N) array_like
        Right-hand side matrix in `a x = b`
    lower : bool, optional
        Use only data contained in the lower triangle of `a`.
        Default is to use upper triangle.
    trans : {0, 1, 2, 'N', 'T', 'C'}, optional
        Type of system to solve:
    
        ========  =========
        trans     system
        ========  =========
        0 or 'N'  a x  = b
        1 or 'T'  a^T x = b
        2 or 'C'  a^H x = b
        ========  =========
    unit_diagonal : bool, optional
        If True, diagonal elements of `a` are assumed to be 1 and
        will not be referenced.
    overwrite_b : bool, optional
        Allow overwriting data in `b` (may enhance performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : (M,) or (M, N) ndarray
        Solution to the system `a x = b`.  Shape of return matches `b`.
    
    Raises
    ------
    LinAlgError
        If `a` is singular
    
    Notes
    -----
    .. versionadded:: 0.9.0
    
    Examples
    --------
    Solve the lower triangular system a x = b, where::
    
             [3  0  0  0]       [4]
        a =  [2  1  0  0]   b = [2]
             [1  0  1  0]       [4]
             [1  1  1  1]       [2]
    
    >>> from scipy.linalg import solve_triangular
    >>> a = np.array([[3, 0, 0, 0], [2, 1, 0, 0], [1, 0, 1, 0], [1, 1, 1, 1]])
    >>> b = np.array([4, 2, 4, 2])
    >>> x = solve_triangular(a, b, lower=True)
    >>> x
    array([ 1.33333333, -0.66666667,  2.66666667, -1.33333333])
    >>> a.dot(x)  # Check the result
    array([ 4.,  2.,  4.,  2.])
",function,"('(a, b, trans=0, lower=False, unit_diagonal=False, overwrite_b=False, debug=None, check_finite=True)',)",scipy,1.1.0,scipy.linalg.basic.solve_triangular,linalg.basic,solve_triangular,"Python Library Documentation: function solve_triangular in module scipy.linalg.basic

solve_triangular(a, b, trans=0, lower=False, unit_diagonal=False, overwrite_b=False, debug=None, check_finite=True)
    Solve the equation `a x = b` for `x`, assuming a is a triangular matrix.
    
    Parameters
    ----------
    a : (M, M) array_like
        A triangular matrix
    b : (M,) or (M, N) array_like
        Right-hand side matrix in `a x = b`
    lower : bool, optional
        Use only data contained in the lower triangle of `a`.
        Default is to use upper triangle.
    trans : {0, 1, 2, 'N', 'T', 'C'}, optional
        Type of system to solve:
    
        ========  =========
        trans     system
        ========  =========
        0 or 'N'  a x  = b
        1 or 'T'  a^T x = b
        2 or 'C'  a^H x = b
        ========  =========
    unit_diagonal : bool, optional
        If True, diagonal elements of `a` are assumed to be 1 and
        will not be referenced.
    overwrite_b : bool, optional
        Allow overwriting data in `b` (may enhance performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : (M,) or (M, N) ndarray
        Solution to the system `a x = b`.  Shape of return matches `b`.
    
    Raises
    ------
    LinAlgError
        If `a` is singular
    
    Notes
    -----
    .. versionadded:: 0.9.0
    
    Examples
    --------
    Solve the lower triangular system a x = b, where::
    
             [3  0  0  0]       [4]
        a =  [2  1  0  0]   b = [2]
             [1  0  1  0]       [4]
             [1  1  1  1]       [2]
    
    >>> from scipy.linalg import solve_triangular
    >>> a = np.array([[3, 0, 0, 0], [2, 1, 0, 0], [1, 0, 1, 0], [1, 1, 1, 1]])
    >>> b = np.array([4, 2, 4, 2])
    >>> x = solve_triangular(a, b, lower=True)
    >>> x
    array([ 1.33333333, -0.66666667,  2.66666667, -1.33333333])
    >>> a.dot(x)  # Check the result
    array([ 4.,  2.,  4.,  2.])
",function,"('a', 'b', 'trans', 'lower', 'unit_diagonal', 'overwrite_b', 'debug', 'check_finite')","(nan, nan, 0, False, False, False, None, True)","(nan, nan, 'int', 'bool', 'bool', 'bool', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, b, trans=0, lower=False, unit_diagonal=False, overwrite_b=False, debug=None, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.basic.solveh_banded,linalg.basic,solveh_banded,"Python Library Documentation: function solveh_banded in module scipy.linalg.basic

solveh_banded(ab, b, overwrite_ab=False, overwrite_b=False, lower=False, check_finite=True)
    Solve equation a x = b. a is Hermitian positive-definite banded matrix.
    
    The matrix a is stored in `ab` either in lower diagonal or upper
    diagonal ordered form:
    
        ab[u + i - j, j] == a[i,j]        (if upper form; i <= j)
        ab[    i - j, j] == a[i,j]        (if lower form; i >= j)
    
    Example of `ab` (shape of a is (6, 6), `u` =2)::
    
        upper form:
        *   *   a02 a13 a24 a35
        *   a01 a12 a23 a34 a45
        a00 a11 a22 a33 a44 a55
    
        lower form:
        a00 a11 a22 a33 a44 a55
        a10 a21 a32 a43 a54 *
        a20 a31 a42 a53 *   *
    
    Cells marked with * are not used.
    
    Parameters
    ----------
    ab : (`u` + 1, M) array_like
        Banded matrix
    b : (M,) or (M, K) array_like
        Right-hand side
    overwrite_ab : bool, optional
        Discard data in `ab` (may enhance performance)
    overwrite_b : bool, optional
        Discard data in `b` (may enhance performance)
    lower : bool, optional
        Is the matrix in the lower form. (Default is upper form)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : (M,) or (M, K) ndarray
        The solution to the system a x = b.  Shape of return matches shape
        of `b`.
    
    Examples
    --------
    Solve the banded system A x = b, where::
    
            [ 4  2 -1  0  0  0]       [1]
            [ 2  5  2 -1  0  0]       [2]
        A = [-1  2  6  2 -1  0]   b = [2]
            [ 0 -1  2  7  2 -1]       [3]
            [ 0  0 -1  2  8  2]       [3]
            [ 0  0  0 -1  2  9]       [3]
    
    >>> from scipy.linalg import solveh_banded
    
    `ab` contains the main diagonal and the nonzero diagonals below the
    main diagonal.  That is, we use the lower form:
    
    >>> ab = np.array([[ 4,  5,  6,  7, 8, 9],
    ...                [ 2,  2,  2,  2, 2, 0],
    ...                [-1, -1, -1, -1, 0, 0]])
    >>> b = np.array([1, 2, 2, 3, 3, 3])
    >>> x = solveh_banded(ab, b, lower=True)
    >>> x
    array([ 0.03431373,  0.45938375,  0.05602241,  0.47759104,  0.17577031,
            0.34733894])
    
    
    Solve the Hermitian banded system H x = b, where::
    
            [ 8   2-1j   0     0  ]        [ 1  ]
        H = [2+1j  5     1j    0  ]    b = [1+1j]
            [ 0   -1j    9   -2-1j]        [1-2j]
            [ 0    0   -2+1j   6  ]        [ 0  ]
    
    In this example, we put the upper diagonals in the array `hb`:
    
    >>> hb = np.array([[0, 2-1j, 1j, -2-1j],
    ...                [8,  5,    9,   6  ]])
    >>> b = np.array([1, 1+1j, 1-2j, 0])
    >>> x = solveh_banded(hb, b)
    >>> x
    array([ 0.07318536-0.02939412j,  0.11877624+0.17696461j,
            0.10077984-0.23035393j, -0.00479904-0.09358128j])
",function,"('(ab, b, overwrite_ab=False, overwrite_b=False, lower=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.basic.solveh_banded,linalg.basic,solveh_banded,"Python Library Documentation: function solveh_banded in module scipy.linalg.basic

solveh_banded(ab, b, overwrite_ab=False, overwrite_b=False, lower=False, check_finite=True)
    Solve equation a x = b. a is Hermitian positive-definite banded matrix.
    
    The matrix a is stored in `ab` either in lower diagonal or upper
    diagonal ordered form:
    
        ab[u + i - j, j] == a[i,j]        (if upper form; i <= j)
        ab[    i - j, j] == a[i,j]        (if lower form; i >= j)
    
    Example of `ab` (shape of a is (6, 6), `u` =2)::
    
        upper form:
        *   *   a02 a13 a24 a35
        *   a01 a12 a23 a34 a45
        a00 a11 a22 a33 a44 a55
    
        lower form:
        a00 a11 a22 a33 a44 a55
        a10 a21 a32 a43 a54 *
        a20 a31 a42 a53 *   *
    
    Cells marked with * are not used.
    
    Parameters
    ----------
    ab : (`u` + 1, M) array_like
        Banded matrix
    b : (M,) or (M, K) array_like
        Right-hand side
    overwrite_ab : bool, optional
        Discard data in `ab` (may enhance performance)
    overwrite_b : bool, optional
        Discard data in `b` (may enhance performance)
    lower : bool, optional
        Is the matrix in the lower form. (Default is upper form)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : (M,) or (M, K) ndarray
        The solution to the system a x = b.  Shape of return matches shape
        of `b`.
    
    Examples
    --------
    Solve the banded system A x = b, where::
    
            [ 4  2 -1  0  0  0]       [1]
            [ 2  5  2 -1  0  0]       [2]
        A = [-1  2  6  2 -1  0]   b = [2]
            [ 0 -1  2  7  2 -1]       [3]
            [ 0  0 -1  2  8  2]       [3]
            [ 0  0  0 -1  2  9]       [3]
    
    >>> from scipy.linalg import solveh_banded
    
    `ab` contains the main diagonal and the nonzero diagonals below the
    main diagonal.  That is, we use the lower form:
    
    >>> ab = np.array([[ 4,  5,  6,  7, 8, 9],
    ...                [ 2,  2,  2,  2, 2, 0],
    ...                [-1, -1, -1, -1, 0, 0]])
    >>> b = np.array([1, 2, 2, 3, 3, 3])
    >>> x = solveh_banded(ab, b, lower=True)
    >>> x
    array([ 0.03431373,  0.45938375,  0.05602241,  0.47759104,  0.17577031,
            0.34733894])
    
    
    Solve the Hermitian banded system H x = b, where::
    
            [ 8   2-1j   0     0  ]        [ 1  ]
        H = [2+1j  5     1j    0  ]    b = [1+1j]
            [ 0   -1j    9   -2-1j]        [1-2j]
            [ 0    0   -2+1j   6  ]        [ 0  ]
    
    In this example, we put the upper diagonals in the array `hb`:
    
    >>> hb = np.array([[0, 2-1j, 1j, -2-1j],
    ...                [8,  5,    9,   6  ]])
    >>> b = np.array([1, 1+1j, 1-2j, 0])
    >>> x = solveh_banded(hb, b)
    >>> x
    array([ 0.07318536-0.02939412j,  0.11877624+0.17696461j,
            0.10077984-0.23035393j, -0.00479904-0.09358128j])
",function,"('ab', 'b', 'overwrite_ab', 'overwrite_b', 'lower', 'check_finite')","(nan, nan, False, False, False, True)","(nan, nan, 'bool', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(ab, b, overwrite_ab=False, overwrite_b=False, lower=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.blas._get_funcs,linalg.blas,_get_funcs,"Python Library Documentation: function _get_funcs in module scipy.linalg.blas

_get_funcs(names, arrays, dtype, lib_name, fmodule, cmodule, fmodule_name, cmodule_name, alias)
    Return available BLAS/LAPACK functions.
    
    Used also in lapack.py. See get_blas_funcs for docstring.
",function,"('(names, arrays, dtype, lib_name, fmodule, cmodule, fmodule_name, cmodule_name, alias)',)",scipy,1.1.0,scipy.linalg.blas._get_funcs,linalg.blas,_get_funcs,"Python Library Documentation: function _get_funcs in module scipy.linalg.blas

_get_funcs(names, arrays, dtype, lib_name, fmodule, cmodule, fmodule_name, cmodule_name, alias)
    Return available BLAS/LAPACK functions.
    
    Used also in lapack.py. See get_blas_funcs for docstring.
",function,"('names', 'arrays', 'dtype', 'lib_name', 'fmodule', 'cmodule', 'fmodule_name', 'cmodule_name', 'alias')","(nan, nan, nan, nan, nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(names, arrays, dtype, lib_name, fmodule, cmodule, fmodule_name, cmodule_name, alias)',)"
scipy,1.1.0,scipy.linalg.blas.find_best_blas_type,linalg.blas,find_best_blas_type,"Python Library Documentation: function find_best_blas_type in module scipy.linalg.blas

find_best_blas_type(arrays=(), dtype=None)
    Find best-matching BLAS/LAPACK type.
    
    Arrays are used to determine the optimal prefix of BLAS routines.
    
    Parameters
    ----------
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of BLAS
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    prefix : str
        BLAS/LAPACK prefix character.
    dtype : dtype
        Inferred Numpy data type.
    prefer_fortran : bool
        Whether to prefer Fortran order routines over C order.
    
    Examples
    --------
    >>> import scipy.linalg.blas as bla
    >>> a = np.random.rand(10,15)
    >>> b = np.asfortranarray(a)  # Change the memory layout order
    >>> bla.find_best_blas_type((a,))
    ('d', dtype('float64'), False)
    >>> bla.find_best_blas_type((a*1j,))
    ('z', dtype('complex128'), False)
    >>> bla.find_best_blas_type((b,))
    ('d', dtype('float64'), True)
",function,"('(arrays=(), dtype=None)',)",scipy,1.1.0,scipy.linalg.blas.find_best_blas_type,linalg.blas,find_best_blas_type,"Python Library Documentation: function find_best_blas_type in module scipy.linalg.blas

find_best_blas_type(arrays=(), dtype=None)
    Find best-matching BLAS/LAPACK type.
    
    Arrays are used to determine the optimal prefix of BLAS routines.
    
    Parameters
    ----------
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of BLAS
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    prefix : str
        BLAS/LAPACK prefix character.
    dtype : dtype
        Inferred Numpy data type.
    prefer_fortran : bool
        Whether to prefer Fortran order routines over C order.
    
    Examples
    --------
    >>> import scipy.linalg.blas as bla
    >>> a = np.random.rand(10,15)
    >>> b = np.asfortranarray(a)  # Change the memory layout order
    >>> bla.find_best_blas_type((a,))
    ('d', dtype('float64'), False)
    >>> bla.find_best_blas_type((a*1j,))
    ('z', dtype('complex128'), False)
    >>> bla.find_best_blas_type((b,))
    ('d', dtype('float64'), True)
",function,"('arrays', 'dtype')","((), None)","('tuple', 'NoneType')","('arg_info', 'arg_info')","('(arrays=(), dtype=None)',)"
scipy,1.1.0,scipy.linalg.blas.get_blas_funcs,linalg.blas,get_blas_funcs,"Python Library Documentation: function get_blas_funcs in module scipy.linalg.blas

get_blas_funcs(names, arrays=(), dtype=None)
    Return available BLAS function objects from names.
    
    Arrays are used to determine the optimal prefix of BLAS routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of BLAS functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of BLAS
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In BLAS, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively.
    The code and the dtype are stored in attributes `typecode` and `dtype`
    of the returned functions.
    
    Examples
    --------
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_gemv = LA.get_blas_funcs('gemv', (a,))
    >>> x_gemv.typecode
    'd'
    >>> x_gemv = LA.get_blas_funcs('gemv',(a*1j,))
    >>> x_gemv.typecode
    'z'
",function,"('(names, arrays=(), dtype=None)',)",scipy,1.1.0,scipy.linalg.blas.get_blas_funcs,linalg.blas,get_blas_funcs,"Python Library Documentation: function get_blas_funcs in module scipy.linalg.blas

get_blas_funcs(names, arrays=(), dtype=None)
    Return available BLAS function objects from names.
    
    Arrays are used to determine the optimal prefix of BLAS routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of BLAS functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of BLAS
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In BLAS, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively.
    The code and the dtype are stored in attributes `typecode` and `dtype`
    of the returned functions.
    
    Examples
    --------
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_gemv = LA.get_blas_funcs('gemv', (a,))
    >>> x_gemv.typecode
    'd'
    >>> x_gemv = LA.get_blas_funcs('gemv',(a*1j,))
    >>> x_gemv.typecode
    'z'
",function,"('names', 'arrays', 'dtype')","(nan, (), None)","(nan, 'tuple', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(names, arrays=(), dtype=None)',)"
scipy,1.1.0,scipy.linalg.block_diag,linalg,block_diag,"Python Library Documentation: function block_diag in module scipy.linalg.special_matrices

block_diag(*arrs)
    Create a block diagonal matrix from provided arrays.
    
    Given the inputs `A`, `B` and `C`, the output will have these
    arrays arranged on the diagonal::
    
        [[A, 0, 0],
         [0, B, 0],
         [0, 0, C]]
    
    Parameters
    ----------
    A, B, C, ... : array_like, up to 2-D
        Input arrays.  A 1-D array or array_like sequence of length `n` is
        treated as a 2-D array with shape ``(1,n)``.
    
    Returns
    -------
    D : ndarray
        Array with `A`, `B`, `C`, ... on the diagonal.  `D` has the
        same dtype as `A`.
    
    Notes
    -----
    If all the input arrays are square, the output is known as a
    block diagonal matrix.
    
    Empty sequences (i.e., array-likes of zero size) will not be ignored.
    Noteworthy, both [] and [[]] are treated as matrices with shape ``(1,0)``.
    
    Examples
    --------
    >>> from scipy.linalg import block_diag
    >>> A = [[1, 0],
    ...      [0, 1]]
    >>> B = [[3, 4, 5],
    ...      [6, 7, 8]]
    >>> C = [[7]]
    >>> P = np.zeros((2, 0), dtype='int32')
    >>> block_diag(A, B, C)
    array([[1, 0, 0, 0, 0, 0],
           [0, 1, 0, 0, 0, 0],
           [0, 0, 3, 4, 5, 0],
           [0, 0, 6, 7, 8, 0],
           [0, 0, 0, 0, 0, 7]])
    >>> block_diag(A, P, B, C)
    array([[1, 0, 0, 0, 0, 0],
           [0, 1, 0, 0, 0, 0],
           [0, 0, 0, 0, 0, 0],
           [0, 0, 0, 0, 0, 0],
           [0, 0, 3, 4, 5, 0],
           [0, 0, 6, 7, 8, 0],
           [0, 0, 0, 0, 0, 7]])
    >>> block_diag(1.0, [2, 3], [[4, 5], [6, 7]])
    array([[ 1.,  0.,  0.,  0.,  0.],
           [ 0.,  2.,  3.,  0.,  0.],
           [ 0.,  0.,  0.,  4.,  5.],
           [ 0.,  0.,  0.,  6.,  7.]])
",function,"('(*arrs)',)",scipy,1.1.0,scipy.linalg.block_diag,linalg,block_diag,"Python Library Documentation: function block_diag in module scipy.linalg.special_matrices

block_diag(*arrs)
    Create a block diagonal matrix from provided arrays.
    
    Given the inputs `A`, `B` and `C`, the output will have these
    arrays arranged on the diagonal::
    
        [[A, 0, 0],
         [0, B, 0],
         [0, 0, C]]
    
    Parameters
    ----------
    A, B, C, ... : array_like, up to 2-D
        Input arrays.  A 1-D array or array_like sequence of length `n` is
        treated as a 2-D array with shape ``(1,n)``.
    
    Returns
    -------
    D : ndarray
        Array with `A`, `B`, `C`, ... on the diagonal.  `D` has the
        same dtype as `A`.
    
    Notes
    -----
    If all the input arrays are square, the output is known as a
    block diagonal matrix.
    
    Empty sequences (i.e., array-likes of zero size) will not be ignored.
    Noteworthy, both [] and [[]] are treated as matrices with shape ``(1,0)``.
    
    Examples
    --------
    >>> from scipy.linalg import block_diag
    >>> A = [[1, 0],
    ...      [0, 1]]
    >>> B = [[3, 4, 5],
    ...      [6, 7, 8]]
    >>> C = [[7]]
    >>> P = np.zeros((2, 0), dtype='int32')
    >>> block_diag(A, B, C)
    array([[1, 0, 0, 0, 0, 0],
           [0, 1, 0, 0, 0, 0],
           [0, 0, 3, 4, 5, 0],
           [0, 0, 6, 7, 8, 0],
           [0, 0, 0, 0, 0, 7]])
    >>> block_diag(A, P, B, C)
    array([[1, 0, 0, 0, 0, 0],
           [0, 1, 0, 0, 0, 0],
           [0, 0, 0, 0, 0, 0],
           [0, 0, 0, 0, 0, 0],
           [0, 0, 3, 4, 5, 0],
           [0, 0, 6, 7, 8, 0],
           [0, 0, 0, 0, 0, 7]])
    >>> block_diag(1.0, [2, 3], [[4, 5], [6, 7]])
    array([[ 1.,  0.,  0.,  0.,  0.],
           [ 0.,  2.,  3.,  0.,  0.],
           [ 0.,  0.,  0.,  4.,  5.],
           [ 0.,  0.,  0.,  6.,  7.]])
",function,(),(),(),(),"('(*arrs)',)"
scipy,1.1.0,scipy.linalg.cdf2rdf,linalg,cdf2rdf,"Python Library Documentation: function cdf2rdf in module scipy.linalg.decomp

cdf2rdf(w, v)
    Converts complex eigenvalues ``w`` and eigenvectors ``v`` to real
    eigenvalues in a block diagonal form ``wr`` and the associated real
    eigenvectors ``vr``, such that::
    
        vr @ wr = X @ vr
    
    continues to hold, where ``X`` is the original array for which ``w`` and
    ``v`` are the eigenvalues and eigenvectors.
    
    .. versionadded:: 1.1.0
    
    Parameters
    ----------
    w : (..., M) array_like
        Complex or real eigenvalues, an array or stack of arrays
    
        Conjugate pairs must not be interleaved, else the wrong result
        will be produced. So ``[1+1j, 1, 1-1j]`` will give a correct result, but
        ``[1+1j, 2+1j, 1-1j, 2-1j]`` will not.
    
    v : (..., M, M) array_like
        Complex or real eigenvectors, a square array or stack of square arrays.
    
    Returns
    -------
    wr : (..., M, M) ndarray
        Real diagonal block form of eigenvalues
    vr : (..., M, M) ndarray
        Real eigenvectors associated with ``wr``
    
    See Also
    --------
    eig : Eigenvalues and right eigenvectors for non-symmetric arrays
    rsf2csf : Convert real Schur form to complex Schur form
    
    Notes
    -----
    ``w``, ``v`` must be the eigenstructure for some *real* matrix ``X``.
    For example, obtained by ``w, v = scipy.linalg.eig(X)`` or
    ``w, v = numpy.linalg.eig(X)`` in which case ``X`` can also represent
    stacked arrays.
    
    .. versionadded:: 1.1.0
    
    Examples
    --------
    >>> X = np.array([[1, 2, 3], [0, 4, 5], [0, -5, 4]])
    >>> X
    array([[ 1,  2,  3],
           [ 0,  4,  5],
           [ 0, -5,  4]])
    
    >>> from scipy import linalg
    >>> w, v = linalg.eig(X)
    >>> w
    array([ 1.+0.j,  4.+5.j,  4.-5.j])
    >>> v
    array([[ 1.00000+0.j     , -0.01906-0.40016j, -0.01906+0.40016j],
           [ 0.00000+0.j     ,  0.00000-0.64788j,  0.00000+0.64788j],
           [ 0.00000+0.j     ,  0.64788+0.j     ,  0.64788-0.j     ]])
    
    >>> wr, vr = linalg.cdf2rdf(w, v)
    >>> wr
    array([[ 1.,  0.,  0.],
           [ 0.,  4.,  5.],
           [ 0., -5.,  4.]])
    >>> vr
    array([[ 1.     ,  0.40016, -0.01906],
           [ 0.     ,  0.64788,  0.     ],
           [ 0.     ,  0.     ,  0.64788]])
    
    >>> vr @ wr
    array([[ 1.     ,  1.69593,  1.9246 ],
           [ 0.     ,  2.59153,  3.23942],
           [ 0.     , -3.23942,  2.59153]])
    >>> X @ vr
    array([[ 1.     ,  1.69593,  1.9246 ],
           [ 0.     ,  2.59153,  3.23942],
           [ 0.     , -3.23942,  2.59153]])
",function,"('(w, v)',)",scipy,1.1.0,scipy.linalg.cdf2rdf,linalg,cdf2rdf,"Python Library Documentation: function cdf2rdf in module scipy.linalg.decomp

cdf2rdf(w, v)
    Converts complex eigenvalues ``w`` and eigenvectors ``v`` to real
    eigenvalues in a block diagonal form ``wr`` and the associated real
    eigenvectors ``vr``, such that::
    
        vr @ wr = X @ vr
    
    continues to hold, where ``X`` is the original array for which ``w`` and
    ``v`` are the eigenvalues and eigenvectors.
    
    .. versionadded:: 1.1.0
    
    Parameters
    ----------
    w : (..., M) array_like
        Complex or real eigenvalues, an array or stack of arrays
    
        Conjugate pairs must not be interleaved, else the wrong result
        will be produced. So ``[1+1j, 1, 1-1j]`` will give a correct result, but
        ``[1+1j, 2+1j, 1-1j, 2-1j]`` will not.
    
    v : (..., M, M) array_like
        Complex or real eigenvectors, a square array or stack of square arrays.
    
    Returns
    -------
    wr : (..., M, M) ndarray
        Real diagonal block form of eigenvalues
    vr : (..., M, M) ndarray
        Real eigenvectors associated with ``wr``
    
    See Also
    --------
    eig : Eigenvalues and right eigenvectors for non-symmetric arrays
    rsf2csf : Convert real Schur form to complex Schur form
    
    Notes
    -----
    ``w``, ``v`` must be the eigenstructure for some *real* matrix ``X``.
    For example, obtained by ``w, v = scipy.linalg.eig(X)`` or
    ``w, v = numpy.linalg.eig(X)`` in which case ``X`` can also represent
    stacked arrays.
    
    .. versionadded:: 1.1.0
    
    Examples
    --------
    >>> X = np.array([[1, 2, 3], [0, 4, 5], [0, -5, 4]])
    >>> X
    array([[ 1,  2,  3],
           [ 0,  4,  5],
           [ 0, -5,  4]])
    
    >>> from scipy import linalg
    >>> w, v = linalg.eig(X)
    >>> w
    array([ 1.+0.j,  4.+5.j,  4.-5.j])
    >>> v
    array([[ 1.00000+0.j     , -0.01906-0.40016j, -0.01906+0.40016j],
           [ 0.00000+0.j     ,  0.00000-0.64788j,  0.00000+0.64788j],
           [ 0.00000+0.j     ,  0.64788+0.j     ,  0.64788-0.j     ]])
    
    >>> wr, vr = linalg.cdf2rdf(w, v)
    >>> wr
    array([[ 1.,  0.,  0.],
           [ 0.,  4.,  5.],
           [ 0., -5.,  4.]])
    >>> vr
    array([[ 1.     ,  0.40016, -0.01906],
           [ 0.     ,  0.64788,  0.     ],
           [ 0.     ,  0.     ,  0.64788]])
    
    >>> vr @ wr
    array([[ 1.     ,  1.69593,  1.9246 ],
           [ 0.     ,  2.59153,  3.23942],
           [ 0.     , -3.23942,  2.59153]])
    >>> X @ vr
    array([[ 1.     ,  1.69593,  1.9246 ],
           [ 0.     ,  2.59153,  3.23942],
           [ 0.     , -3.23942,  2.59153]])
",function,"('w', 'v')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(w, v)',)"
scipy,1.1.0,scipy.linalg.cho_factor,linalg,cho_factor,"Python Library Documentation: function cho_factor in module scipy.linalg.decomp_cholesky

cho_factor(a, lower=False, overwrite_a=False, check_finite=True)
    Compute the Cholesky decomposition of a matrix, to use in cho_solve
    
    Returns a matrix containing the Cholesky decomposition,
    ``A = L L*`` or ``A = U* U`` of a Hermitian positive-definite matrix `a`.
    The return value can be directly used as the first parameter to cho_solve.
    
    .. warning::
        The returned matrix also contains random data in the entries not
        used by the Cholesky decomposition. If you need to zero these
        entries, use the function `cholesky` instead.
    
    Parameters
    ----------
    a : (M, M) array_like
        Matrix to be decomposed
    lower : bool, optional
        Whether to compute the upper or lower triangular Cholesky factorization
        (Default: upper-triangular)
    overwrite_a : bool, optional
        Whether to overwrite data in a (may improve performance)
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    c : (M, M) ndarray
        Matrix whose upper or lower triangle contains the Cholesky factor
        of `a`. Other parts of the matrix contain random data.
    lower : bool
        Flag indicating whether the factor is in the lower or upper triangle
    
    Raises
    ------
    LinAlgError
        Raised if decomposition fails.
    
    See also
    --------
    cho_solve : Solve a linear set equations using the Cholesky factorization
                of a matrix.
    
    Examples
    --------
    >>> from scipy.linalg import cho_factor
    >>> A = np.array([[9, 3, 1, 5], [3, 7, 5, 1], [1, 5, 9, 2], [5, 1, 2, 6]])
    >>> c, low = cho_factor(A)
    >>> c
    array([[3.        , 1.        , 0.33333333, 1.66666667],
           [3.        , 2.44948974, 1.90515869, -0.27216553],
           [1.        , 5.        , 2.29330749, 0.8559528 ],
           [5.        , 1.        , 2.        , 1.55418563]])
    >>> np.allclose(np.triu(c).T @ np. triu(c) - A, np.zeros((4, 4)))
    True
",function,"('(a, lower=False, overwrite_a=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.cho_factor,linalg,cho_factor,"Python Library Documentation: function cho_factor in module scipy.linalg.decomp_cholesky

cho_factor(a, lower=False, overwrite_a=False, check_finite=True)
    Compute the Cholesky decomposition of a matrix, to use in cho_solve
    
    Returns a matrix containing the Cholesky decomposition,
    ``A = L L*`` or ``A = U* U`` of a Hermitian positive-definite matrix `a`.
    The return value can be directly used as the first parameter to cho_solve.
    
    .. warning::
        The returned matrix also contains random data in the entries not
        used by the Cholesky decomposition. If you need to zero these
        entries, use the function `cholesky` instead.
    
    Parameters
    ----------
    a : (M, M) array_like
        Matrix to be decomposed
    lower : bool, optional
        Whether to compute the upper or lower triangular Cholesky factorization
        (Default: upper-triangular)
    overwrite_a : bool, optional
        Whether to overwrite data in a (may improve performance)
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    c : (M, M) ndarray
        Matrix whose upper or lower triangle contains the Cholesky factor
        of `a`. Other parts of the matrix contain random data.
    lower : bool
        Flag indicating whether the factor is in the lower or upper triangle
    
    Raises
    ------
    LinAlgError
        Raised if decomposition fails.
    
    See also
    --------
    cho_solve : Solve a linear set equations using the Cholesky factorization
                of a matrix.
    
    Examples
    --------
    >>> from scipy.linalg import cho_factor
    >>> A = np.array([[9, 3, 1, 5], [3, 7, 5, 1], [1, 5, 9, 2], [5, 1, 2, 6]])
    >>> c, low = cho_factor(A)
    >>> c
    array([[3.        , 1.        , 0.33333333, 1.66666667],
           [3.        , 2.44948974, 1.90515869, -0.27216553],
           [1.        , 5.        , 2.29330749, 0.8559528 ],
           [5.        , 1.        , 2.        , 1.55418563]])
    >>> np.allclose(np.triu(c).T @ np. triu(c) - A, np.zeros((4, 4)))
    True
",function,"('a', 'lower', 'overwrite_a', 'check_finite')","(nan, False, False, True)","(nan, 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, lower=False, overwrite_a=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.cho_solve,linalg,cho_solve,"Python Library Documentation: function cho_solve in module scipy.linalg.decomp_cholesky

cho_solve(c_and_lower, b, overwrite_b=False, check_finite=True)
    Solve the linear equations A x = b, given the Cholesky factorization of A.
    
    Parameters
    ----------
    (c, lower) : tuple, (array, bool)
        Cholesky factorization of a, as given by cho_factor
    b : array
        Right-hand side
    overwrite_b : bool, optional
        Whether to overwrite data in b (may improve performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : array
        The solution to the system A x = b
    
    See also
    --------
    cho_factor : Cholesky factorization of a matrix
    
    Examples
    --------
    >>> from scipy.linalg import cho_factor, cho_solve
    >>> A = np.array([[9, 3, 1, 5], [3, 7, 5, 1], [1, 5, 9, 2], [5, 1, 2, 6]])
    >>> c, low = cho_factor(A)
    >>> x = cho_solve((c, low), [1, 1, 1, 1])
    >>> np.allclose(A @ x - [1, 1, 1, 1], np.zeros(4))
    True
",function,"('(c_and_lower, b, overwrite_b=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.cho_solve,linalg,cho_solve,"Python Library Documentation: function cho_solve in module scipy.linalg.decomp_cholesky

cho_solve(c_and_lower, b, overwrite_b=False, check_finite=True)
    Solve the linear equations A x = b, given the Cholesky factorization of A.
    
    Parameters
    ----------
    (c, lower) : tuple, (array, bool)
        Cholesky factorization of a, as given by cho_factor
    b : array
        Right-hand side
    overwrite_b : bool, optional
        Whether to overwrite data in b (may improve performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : array
        The solution to the system A x = b
    
    See also
    --------
    cho_factor : Cholesky factorization of a matrix
    
    Examples
    --------
    >>> from scipy.linalg import cho_factor, cho_solve
    >>> A = np.array([[9, 3, 1, 5], [3, 7, 5, 1], [1, 5, 9, 2], [5, 1, 2, 6]])
    >>> c, low = cho_factor(A)
    >>> x = cho_solve((c, low), [1, 1, 1, 1])
    >>> np.allclose(A @ x - [1, 1, 1, 1], np.zeros(4))
    True
",function,"('c_and_lower', 'b', 'overwrite_b', 'check_finite')","(nan, nan, False, True)","(nan, nan, 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(c_and_lower, b, overwrite_b=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.cho_solve_banded,linalg,cho_solve_banded,"Python Library Documentation: function cho_solve_banded in module scipy.linalg.decomp_cholesky

cho_solve_banded(cb_and_lower, b, overwrite_b=False, check_finite=True)
    Solve the linear equations ``A x = b``, given the Cholesky factorization of
    the banded hermitian ``A``.
    
    Parameters
    ----------
    (cb, lower) : tuple, (ndarray, bool)
        `cb` is the Cholesky factorization of A, as given by cholesky_banded.
        `lower` must be the same value that was given to cholesky_banded.
    b : array_like
        Right-hand side
    overwrite_b : bool, optional
        If True, the function will overwrite the values in `b`.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : array
        The solution to the system A x = b
    
    See also
    --------
    cholesky_banded : Cholesky factorization of a banded matrix
    
    Notes
    -----
    
    .. versionadded:: 0.8.0
    
    Examples
    --------
    >>> from scipy.linalg import cholesky_banded, cho_solve_banded
    >>> Ab = np.array([[0, 0, 1j, 2, 3j], [0, -1, -2, 3, 4], [9, 8, 7, 6, 9]])
    >>> A = np.diag(Ab[0,2:], k=2) + np.diag(Ab[1,1:], k=1)
    >>> A = A + A.conj().T + np.diag(Ab[2, :])
    >>> c = cholesky_banded(Ab)
    >>> x = cho_solve_banded((c, False), np.ones(5))
    >>> np.allclose(A @ x - np.ones(5), np.zeros(5))
    True
",function,"('(cb_and_lower, b, overwrite_b=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.cho_solve_banded,linalg,cho_solve_banded,"Python Library Documentation: function cho_solve_banded in module scipy.linalg.decomp_cholesky

cho_solve_banded(cb_and_lower, b, overwrite_b=False, check_finite=True)
    Solve the linear equations ``A x = b``, given the Cholesky factorization of
    the banded hermitian ``A``.
    
    Parameters
    ----------
    (cb, lower) : tuple, (ndarray, bool)
        `cb` is the Cholesky factorization of A, as given by cholesky_banded.
        `lower` must be the same value that was given to cholesky_banded.
    b : array_like
        Right-hand side
    overwrite_b : bool, optional
        If True, the function will overwrite the values in `b`.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : array
        The solution to the system A x = b
    
    See also
    --------
    cholesky_banded : Cholesky factorization of a banded matrix
    
    Notes
    -----
    
    .. versionadded:: 0.8.0
    
    Examples
    --------
    >>> from scipy.linalg import cholesky_banded, cho_solve_banded
    >>> Ab = np.array([[0, 0, 1j, 2, 3j], [0, -1, -2, 3, 4], [9, 8, 7, 6, 9]])
    >>> A = np.diag(Ab[0,2:], k=2) + np.diag(Ab[1,1:], k=1)
    >>> A = A + A.conj().T + np.diag(Ab[2, :])
    >>> c = cholesky_banded(Ab)
    >>> x = cho_solve_banded((c, False), np.ones(5))
    >>> np.allclose(A @ x - np.ones(5), np.zeros(5))
    True
",function,"('cb_and_lower', 'b', 'overwrite_b', 'check_finite')","(nan, nan, False, True)","(nan, nan, 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(cb_and_lower, b, overwrite_b=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.cholesky,linalg,cholesky,"Python Library Documentation: function cholesky in module scipy.linalg.decomp_cholesky

cholesky(a, lower=False, overwrite_a=False, check_finite=True)
    Compute the Cholesky decomposition of a matrix.
    
    Returns the Cholesky decomposition, :math:`A = L L^*` or
    :math:`A = U^* U` of a Hermitian positive-definite matrix A.
    
    Parameters
    ----------
    a : (M, M) array_like
        Matrix to be decomposed
    lower : bool, optional
        Whether to compute the upper or lower triangular Cholesky
        factorization.  Default is upper-triangular.
    overwrite_a : bool, optional
        Whether to overwrite data in `a` (may improve performance).
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    c : (M, M) ndarray
        Upper- or lower-triangular Cholesky factor of `a`.
    
    Raises
    ------
    LinAlgError : if decomposition fails.
    
    Examples
    --------
    >>> from scipy.linalg import cholesky
    >>> a = np.array([[1,-2j],[2j,5]])
    >>> L = cholesky(a, lower=True)
    >>> L
    array([[ 1.+0.j,  0.+0.j],
           [ 0.+2.j,  1.+0.j]])
    >>> L @ L.T.conj()
    array([[ 1.+0.j,  0.-2.j],
           [ 0.+2.j,  5.+0.j]])
",function,"('(a, lower=False, overwrite_a=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.cholesky,linalg,cholesky,"Python Library Documentation: function cholesky in module scipy.linalg.decomp_cholesky

cholesky(a, lower=False, overwrite_a=False, check_finite=True)
    Compute the Cholesky decomposition of a matrix.
    
    Returns the Cholesky decomposition, :math:`A = L L^*` or
    :math:`A = U^* U` of a Hermitian positive-definite matrix A.
    
    Parameters
    ----------
    a : (M, M) array_like
        Matrix to be decomposed
    lower : bool, optional
        Whether to compute the upper or lower triangular Cholesky
        factorization.  Default is upper-triangular.
    overwrite_a : bool, optional
        Whether to overwrite data in `a` (may improve performance).
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    c : (M, M) ndarray
        Upper- or lower-triangular Cholesky factor of `a`.
    
    Raises
    ------
    LinAlgError : if decomposition fails.
    
    Examples
    --------
    >>> from scipy.linalg import cholesky
    >>> a = np.array([[1,-2j],[2j,5]])
    >>> L = cholesky(a, lower=True)
    >>> L
    array([[ 1.+0.j,  0.+0.j],
           [ 0.+2.j,  1.+0.j]])
    >>> L @ L.T.conj()
    array([[ 1.+0.j,  0.-2.j],
           [ 0.+2.j,  5.+0.j]])
",function,"('a', 'lower', 'overwrite_a', 'check_finite')","(nan, False, False, True)","(nan, 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, lower=False, overwrite_a=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.cholesky_banded,linalg,cholesky_banded,"Python Library Documentation: function cholesky_banded in module scipy.linalg.decomp_cholesky

cholesky_banded(ab, overwrite_ab=False, lower=False, check_finite=True)
    Cholesky decompose a banded Hermitian positive-definite matrix
    
    The matrix a is stored in ab either in lower diagonal or upper
    diagonal ordered form::
    
        ab[u + i - j, j] == a[i,j]        (if upper form; i <= j)
        ab[    i - j, j] == a[i,j]        (if lower form; i >= j)
    
    Example of ab (shape of a is (6,6), u=2)::
    
        upper form:
        *   *   a02 a13 a24 a35
        *   a01 a12 a23 a34 a45
        a00 a11 a22 a33 a44 a55
    
        lower form:
        a00 a11 a22 a33 a44 a55
        a10 a21 a32 a43 a54 *
        a20 a31 a42 a53 *   *
    
    Parameters
    ----------
    ab : (u + 1, M) array_like
        Banded matrix
    overwrite_ab : bool, optional
        Discard data in ab (may enhance performance)
    lower : bool, optional
        Is the matrix in the lower form. (Default is upper form)
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    c : (u + 1, M) ndarray
        Cholesky factorization of a, in the same banded format as ab
    
    Examples
    --------
    >>> from scipy.linalg import cholesky_banded
    >>> from numpy import allclose, zeros, diag
    >>> Ab = np.array([[0, 0, 1j, 2, 3j], [0, -1, -2, 3, 4], [9, 8, 7, 6, 9]])
    >>> A = np.diag(Ab[0,2:], k=2) + np.diag(Ab[1,1:], k=1)
    >>> A = A + A.conj().T + np.diag(Ab[2, :])
    >>> c = cholesky_banded(Ab)
    >>> C = np.diag(c[0, 2:], k=2) + np.diag(c[1, 1:], k=1) + np.diag(c[2, :])
    >>> np.allclose(C.conj().T @ C - A, np.zeros((5, 5)))
    True
",function,"('(ab, overwrite_ab=False, lower=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.cholesky_banded,linalg,cholesky_banded,"Python Library Documentation: function cholesky_banded in module scipy.linalg.decomp_cholesky

cholesky_banded(ab, overwrite_ab=False, lower=False, check_finite=True)
    Cholesky decompose a banded Hermitian positive-definite matrix
    
    The matrix a is stored in ab either in lower diagonal or upper
    diagonal ordered form::
    
        ab[u + i - j, j] == a[i,j]        (if upper form; i <= j)
        ab[    i - j, j] == a[i,j]        (if lower form; i >= j)
    
    Example of ab (shape of a is (6,6), u=2)::
    
        upper form:
        *   *   a02 a13 a24 a35
        *   a01 a12 a23 a34 a45
        a00 a11 a22 a33 a44 a55
    
        lower form:
        a00 a11 a22 a33 a44 a55
        a10 a21 a32 a43 a54 *
        a20 a31 a42 a53 *   *
    
    Parameters
    ----------
    ab : (u + 1, M) array_like
        Banded matrix
    overwrite_ab : bool, optional
        Discard data in ab (may enhance performance)
    lower : bool, optional
        Is the matrix in the lower form. (Default is upper form)
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    c : (u + 1, M) ndarray
        Cholesky factorization of a, in the same banded format as ab
    
    Examples
    --------
    >>> from scipy.linalg import cholesky_banded
    >>> from numpy import allclose, zeros, diag
    >>> Ab = np.array([[0, 0, 1j, 2, 3j], [0, -1, -2, 3, 4], [9, 8, 7, 6, 9]])
    >>> A = np.diag(Ab[0,2:], k=2) + np.diag(Ab[1,1:], k=1)
    >>> A = A + A.conj().T + np.diag(Ab[2, :])
    >>> c = cholesky_banded(Ab)
    >>> C = np.diag(c[0, 2:], k=2) + np.diag(c[1, 1:], k=1) + np.diag(c[2, :])
    >>> np.allclose(C.conj().T @ C - A, np.zeros((5, 5)))
    True
",function,"('ab', 'overwrite_ab', 'lower', 'check_finite')","(nan, False, False, True)","(nan, 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(ab, overwrite_ab=False, lower=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.circulant,linalg,circulant,"Python Library Documentation: function circulant in module scipy.linalg.special_matrices

circulant(c)
    Construct a circulant matrix.
    
    Parameters
    ----------
    c : (N,) array_like
        1-D array, the first column of the matrix.
    
    Returns
    -------
    A : (N, N) ndarray
        A circulant matrix whose first column is `c`.
    
    See Also
    --------
    toeplitz : Toeplitz matrix
    hankel : Hankel matrix
    solve_circulant : Solve a circulant system.
    
    Notes
    -----
    .. versionadded:: 0.8.0
    
    Examples
    --------
    >>> from scipy.linalg import circulant
    >>> circulant([1, 2, 3])
    array([[1, 3, 2],
           [2, 1, 3],
           [3, 2, 1]])
",function,"('(c)',)",scipy,1.1.0,scipy.linalg.circulant,linalg,circulant,"Python Library Documentation: function circulant in module scipy.linalg.special_matrices

circulant(c)
    Construct a circulant matrix.
    
    Parameters
    ----------
    c : (N,) array_like
        1-D array, the first column of the matrix.
    
    Returns
    -------
    A : (N, N) ndarray
        A circulant matrix whose first column is `c`.
    
    See Also
    --------
    toeplitz : Toeplitz matrix
    hankel : Hankel matrix
    solve_circulant : Solve a circulant system.
    
    Notes
    -----
    .. versionadded:: 0.8.0
    
    Examples
    --------
    >>> from scipy.linalg import circulant
    >>> circulant([1, 2, 3])
    array([[1, 3, 2],
           [2, 1, 3],
           [3, 2, 1]])
",function,"('c',)","(nan,)","(nan,)","('arg_info',)","('(c)',)"
scipy,1.1.0,scipy.linalg.clarkson_woodruff_transform,linalg,clarkson_woodruff_transform,"Python Library Documentation: function clarkson_woodruff_transform in module scipy.linalg._sketches

clarkson_woodruff_transform(input_matrix, sketch_size, seed=None)
    ""
    Find low-rank matrix approximation via the Clarkson-Woodruff Transform.
    
    Given an input_matrix ``A`` of size ``(n, d)``, compute a matrix ``A'`` of
    size (sketch_size, d) which holds:
    
    .. math:: ||Ax|| = (1 \pm \epsilon)||A'x||
    
    with high probability.
    
    The error is related to the number of rows of the sketch and it is bounded
    
    .. math:: poly(r(\epsilon^{-1}))
    
    Parameters
    ----------
    input_matrix: array_like
        Input matrix, of shape ``(n, d)``.
    sketch_size: int
        Number of rows for the sketch.
    seed : None or int or `numpy.random.RandomState` instance, optional
        This parameter defines the ``RandomState`` object to use for drawing
        random variates.
        If None (or ``np.random``), the global ``np.random`` state is used.
        If integer, it is used to seed the local ``RandomState`` instance.
        Default is None.
    
    Returns
    -------
    A' : array_like
        Sketch of the input matrix ``A``, of size ``(sketch_size, d)``.
    
    Notes
    -----
    This is an implementation of the Clarkson-Woodruff Transform (CountSketch).
    ``A'`` can be computed in principle in ``O(nnz(A))`` (with ``nnz`` meaning
    the number of nonzero entries), however we don't take advantage of sparse
    matrices in this implementation.
    
    Examples
    --------
    Given a big dense matrix ``A``:
    
    >>> from scipy import linalg
    >>> n_rows, n_columns, sketch_n_rows = (2000, 100, 100)
    >>> threshold = 0.1
    >>> tmp = np.random.normal(0, 0.1, n_rows*n_columns)
    >>> A = np.reshape(tmp, (n_rows, n_columns))
    >>> sketch = linalg.clarkson_woodruff_transform(A, sketch_n_rows)
    >>> sketch.shape
    (100, 100)
    >>> normA = linalg.norm(A)
    >>> norm_sketch = linalg.norm(sketch)
    
    Now with high probability, the condition ``abs(normA-normSketch) <
    threshold`` holds.
    
    References
    ----------
    .. [1] Kenneth L. Clarkson and David P. Woodruff. Low rank approximation and
           regression in input sparsity time. In STOC, 2013.
",function,"('(input_matrix, sketch_size, seed=None)',)",scipy,1.1.0,scipy.linalg.clarkson_woodruff_transform,linalg,clarkson_woodruff_transform,"Python Library Documentation: function clarkson_woodruff_transform in module scipy.linalg._sketches

clarkson_woodruff_transform(input_matrix, sketch_size, seed=None)
    ""
    Find low-rank matrix approximation via the Clarkson-Woodruff Transform.
    
    Given an input_matrix ``A`` of size ``(n, d)``, compute a matrix ``A'`` of
    size (sketch_size, d) which holds:
    
    .. math:: ||Ax|| = (1 \pm \epsilon)||A'x||
    
    with high probability.
    
    The error is related to the number of rows of the sketch and it is bounded
    
    .. math:: poly(r(\epsilon^{-1}))
    
    Parameters
    ----------
    input_matrix: array_like
        Input matrix, of shape ``(n, d)``.
    sketch_size: int
        Number of rows for the sketch.
    seed : None or int or `numpy.random.RandomState` instance, optional
        This parameter defines the ``RandomState`` object to use for drawing
        random variates.
        If None (or ``np.random``), the global ``np.random`` state is used.
        If integer, it is used to seed the local ``RandomState`` instance.
        Default is None.
    
    Returns
    -------
    A' : array_like
        Sketch of the input matrix ``A``, of size ``(sketch_size, d)``.
    
    Notes
    -----
    This is an implementation of the Clarkson-Woodruff Transform (CountSketch).
    ``A'`` can be computed in principle in ``O(nnz(A))`` (with ``nnz`` meaning
    the number of nonzero entries), however we don't take advantage of sparse
    matrices in this implementation.
    
    Examples
    --------
    Given a big dense matrix ``A``:
    
    >>> from scipy import linalg
    >>> n_rows, n_columns, sketch_n_rows = (2000, 100, 100)
    >>> threshold = 0.1
    >>> tmp = np.random.normal(0, 0.1, n_rows*n_columns)
    >>> A = np.reshape(tmp, (n_rows, n_columns))
    >>> sketch = linalg.clarkson_woodruff_transform(A, sketch_n_rows)
    >>> sketch.shape
    (100, 100)
    >>> normA = linalg.norm(A)
    >>> norm_sketch = linalg.norm(sketch)
    
    Now with high probability, the condition ``abs(normA-normSketch) <
    threshold`` holds.
    
    References
    ----------
    .. [1] Kenneth L. Clarkson and David P. Woodruff. Low rank approximation and
           regression in input sparsity time. In STOC, 2013.
",function,"('input_matrix', 'sketch_size', 'seed')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(input_matrix, sketch_size, seed=None)',)"
scipy,1.1.0,scipy.linalg.companion,linalg,companion,"Python Library Documentation: function companion in module scipy.linalg.special_matrices

companion(a)
    Create a companion matrix.
    
    Create the companion matrix [1]_ associated with the polynomial whose
    coefficients are given in `a`.
    
    Parameters
    ----------
    a : (N,) array_like
        1-D array of polynomial coefficients.  The length of `a` must be
        at least two, and ``a[0]`` must not be zero.
    
    Returns
    -------
    c : (N-1, N-1) ndarray
        The first row of `c` is ``-a[1:]/a[0]``, and the first
        sub-diagonal is all ones.  The data-type of the array is the same
        as the data-type of ``1.0*a[0]``.
    
    Raises
    ------
    ValueError
        If any of the following are true: a) ``a.ndim != 1``;
        b) ``a.size < 2``; c) ``a[0] == 0``.
    
    Notes
    -----
    .. versionadded:: 0.8.0
    
    References
    ----------
    .. [1] R. A. Horn & C. R. Johnson, *Matrix Analysis*.  Cambridge, UK:
        Cambridge University Press, 1999, pp. 146-7.
    
    Examples
    --------
    >>> from scipy.linalg import companion
    >>> companion([1, -10, 31, -30])
    array([[ 10., -31.,  30.],
           [  1.,   0.,   0.],
           [  0.,   1.,   0.]])
",function,"('(a)',)",scipy,1.1.0,scipy.linalg.companion,linalg,companion,"Python Library Documentation: function companion in module scipy.linalg.special_matrices

companion(a)
    Create a companion matrix.
    
    Create the companion matrix [1]_ associated with the polynomial whose
    coefficients are given in `a`.
    
    Parameters
    ----------
    a : (N,) array_like
        1-D array of polynomial coefficients.  The length of `a` must be
        at least two, and ``a[0]`` must not be zero.
    
    Returns
    -------
    c : (N-1, N-1) ndarray
        The first row of `c` is ``-a[1:]/a[0]``, and the first
        sub-diagonal is all ones.  The data-type of the array is the same
        as the data-type of ``1.0*a[0]``.
    
    Raises
    ------
    ValueError
        If any of the following are true: a) ``a.ndim != 1``;
        b) ``a.size < 2``; c) ``a[0] == 0``.
    
    Notes
    -----
    .. versionadded:: 0.8.0
    
    References
    ----------
    .. [1] R. A. Horn & C. R. Johnson, *Matrix Analysis*.  Cambridge, UK:
        Cambridge University Press, 1999, pp. 146-7.
    
    Examples
    --------
    >>> from scipy.linalg import companion
    >>> companion([1, -10, 31, -30])
    array([[ 10., -31.,  30.],
           [  1.,   0.,   0.],
           [  0.,   1.,   0.]])
",function,"('a',)","(nan,)","(nan,)","('arg_info',)","('(a)',)"
scipy,1.1.0,scipy.linalg.coshm,linalg,coshm,"Python Library Documentation: function coshm in module scipy.linalg.matfuncs

coshm(A)
    Compute the hyperbolic matrix cosine.
    
    This routine uses expm to compute the matrix exponentials.
    
    Parameters
    ----------
    A : (N, N) array_like
        Input array.
    
    Returns
    -------
    coshm : (N, N) ndarray
        Hyperbolic matrix cosine of `A`
    
    Examples
    --------
    >>> from scipy.linalg import tanhm, sinhm, coshm
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> c = coshm(a)
    >>> c
    array([[ 11.24592233,  38.76236492],
           [ 12.92078831,  50.00828725]])
    
    Verify tanhm(a) = sinhm(a).dot(inv(coshm(a)))
    
    >>> t = tanhm(a)
    >>> s = sinhm(a)
    >>> t - s.dot(np.linalg.inv(c))
    array([[  2.72004641e-15,   4.55191440e-15],
           [  0.00000000e+00,  -5.55111512e-16]])
",function,"('(A)',)",scipy,1.1.0,scipy.linalg.coshm,linalg,coshm,"Python Library Documentation: function coshm in module scipy.linalg.matfuncs

coshm(A)
    Compute the hyperbolic matrix cosine.
    
    This routine uses expm to compute the matrix exponentials.
    
    Parameters
    ----------
    A : (N, N) array_like
        Input array.
    
    Returns
    -------
    coshm : (N, N) ndarray
        Hyperbolic matrix cosine of `A`
    
    Examples
    --------
    >>> from scipy.linalg import tanhm, sinhm, coshm
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> c = coshm(a)
    >>> c
    array([[ 11.24592233,  38.76236492],
           [ 12.92078831,  50.00828725]])
    
    Verify tanhm(a) = sinhm(a).dot(inv(coshm(a)))
    
    >>> t = tanhm(a)
    >>> s = sinhm(a)
    >>> t - s.dot(np.linalg.inv(c))
    array([[  2.72004641e-15,   4.55191440e-15],
           [  0.00000000e+00,  -5.55111512e-16]])
",function,"('A',)","(nan,)","(nan,)","('arg_info',)","('(A)',)"
scipy,1.1.0,scipy.linalg.cosm,linalg,cosm,"Python Library Documentation: function cosm in module scipy.linalg.matfuncs

cosm(A)
    Compute the matrix cosine.
    
    This routine uses expm to compute the matrix exponentials.
    
    Parameters
    ----------
    A : (N, N) array_like
        Input array
    
    Returns
    -------
    cosm : (N, N) ndarray
        Matrix cosine of A
    
    Examples
    --------
    >>> from scipy.linalg import expm, sinm, cosm
    
    Euler's identity (exp(i*theta) = cos(theta) + i*sin(theta))
    applied to a matrix:
    
    >>> a = np.array([[1.0, 2.0], [-1.0, 3.0]])
    >>> expm(1j*a)
    array([[ 0.42645930+1.89217551j, -2.13721484-0.97811252j],
           [ 1.06860742+0.48905626j, -1.71075555+0.91406299j]])
    >>> cosm(a) + 1j*sinm(a)
    array([[ 0.42645930+1.89217551j, -2.13721484-0.97811252j],
           [ 1.06860742+0.48905626j, -1.71075555+0.91406299j]])
",function,"('(A)',)",scipy,1.1.0,scipy.linalg.cosm,linalg,cosm,"Python Library Documentation: function cosm in module scipy.linalg.matfuncs

cosm(A)
    Compute the matrix cosine.
    
    This routine uses expm to compute the matrix exponentials.
    
    Parameters
    ----------
    A : (N, N) array_like
        Input array
    
    Returns
    -------
    cosm : (N, N) ndarray
        Matrix cosine of A
    
    Examples
    --------
    >>> from scipy.linalg import expm, sinm, cosm
    
    Euler's identity (exp(i*theta) = cos(theta) + i*sin(theta))
    applied to a matrix:
    
    >>> a = np.array([[1.0, 2.0], [-1.0, 3.0]])
    >>> expm(1j*a)
    array([[ 0.42645930+1.89217551j, -2.13721484-0.97811252j],
           [ 1.06860742+0.48905626j, -1.71075555+0.91406299j]])
    >>> cosm(a) + 1j*sinm(a)
    array([[ 0.42645930+1.89217551j, -2.13721484-0.97811252j],
           [ 1.06860742+0.48905626j, -1.71075555+0.91406299j]])
",function,"('A',)","(nan,)","(nan,)","('arg_info',)","('(A)',)"
scipy,1.1.0,scipy.linalg.decomp.LinAlgError,linalg.decomp,LinAlgError,"Python Library Documentation: class LinAlgError in module numpy.linalg.linalg

class LinAlgError(builtins.Exception)
 |  Generic Python-exception-derived object raised by linalg functions.
 |  
 |  General purpose exception class, derived from Python's exception.Exception
 |  class, programmatically raised in linalg functions when a Linear
 |  Algebra-related condition would prevent further correct execution of the
 |  function.
 |  
 |  Parameters
 |  ----------
 |  None
 |  
 |  Examples
 |  --------
 |  >>> from numpy import linalg as LA
 |  >>> LA.inv(np.zeros((2,2)))
 |  Traceback (most recent call last):
 |    File ""<stdin>"", line 1, in <module>
 |    File ""...linalg.py"", line 350,
 |      in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
 |    File ""...linalg.py"", line 249,
 |      in solve
 |      raise LinAlgError('Singular matrix')
 |  numpy.linalg.LinAlgError: Singular matrix
 |  
 |  Method resolution order:
 |      LinAlgError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg.decomp.LinAlgError,linalg.decomp,LinAlgError,"Python Library Documentation: class LinAlgError in module numpy.linalg.linalg

class LinAlgError(builtins.Exception)
 |  Generic Python-exception-derived object raised by linalg functions.
 |  
 |  General purpose exception class, derived from Python's exception.Exception
 |  class, programmatically raised in linalg functions when a Linear
 |  Algebra-related condition would prevent further correct execution of the
 |  function.
 |  
 |  Parameters
 |  ----------
 |  None
 |  
 |  Examples
 |  --------
 |  >>> from numpy import linalg as LA
 |  >>> LA.inv(np.zeros((2,2)))
 |  Traceback (most recent call last):
 |    File ""<stdin>"", line 1, in <module>
 |    File ""...linalg.py"", line 350,
 |      in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
 |    File ""...linalg.py"", line 249,
 |      in solve
 |      raise LinAlgError('Singular matrix')
 |  numpy.linalg.LinAlgError: Singular matrix
 |  
 |  Method resolution order:
 |      LinAlgError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg.decomp._asarray_validated,linalg.decomp,_asarray_validated,"Python Library Documentation: function _asarray_validated in module scipy._lib._util

_asarray_validated(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)
    Helper function for scipy argument validation.
    
    Many scipy linear algebra functions do support arbitrary array-like
    input arguments.  Examples of commonly unsupported inputs include
    matrices containing inf/nan, sparse matrix representations, and
    matrices with complicated elements.
    
    Parameters
    ----------
    a : array_like
        The array-like input.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default: True
    sparse_ok : bool, optional
        True if scipy sparse matrices are allowed.
    objects_ok : bool, optional
        True if arrays with dype('O') are allowed.
    mask_ok : bool, optional
        True if masked arrays are allowed.
    as_inexact : bool, optional
        True to convert the input array to a np.inexact dtype.
    
    Returns
    -------
    ret : ndarray
        The converted validated array.
",function,"('(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)',)",scipy,1.1.0,scipy.linalg.decomp._asarray_validated,linalg.decomp,_asarray_validated,"Python Library Documentation: function _asarray_validated in module scipy._lib._util

_asarray_validated(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)
    Helper function for scipy argument validation.
    
    Many scipy linear algebra functions do support arbitrary array-like
    input arguments.  Examples of commonly unsupported inputs include
    matrices containing inf/nan, sparse matrix representations, and
    matrices with complicated elements.
    
    Parameters
    ----------
    a : array_like
        The array-like input.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default: True
    sparse_ok : bool, optional
        True if scipy sparse matrices are allowed.
    objects_ok : bool, optional
        True if arrays with dype('O') are allowed.
    mask_ok : bool, optional
        True if masked arrays are allowed.
    as_inexact : bool, optional
        True to convert the input array to a np.inexact dtype.
    
    Returns
    -------
    ret : ndarray
        The converted validated array.
",function,"('a', 'check_finite', 'sparse_ok', 'objects_ok', 'mask_ok', 'as_inexact')","(nan, True, False, False, False, False)","(nan, 'bool', 'bool', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)',)"
scipy,1.1.0,scipy.linalg.decomp._check_info,linalg.decomp,_check_info,"Python Library Documentation: function _check_info in module scipy.linalg.decomp

_check_info(info, driver, positive='did not converge (LAPACK info=%d)')
    Check info return value.
",function,"(""(info, driver, positive='did not converge (LAPACK info=%d)')"",)",scipy,1.1.0,scipy.linalg.decomp._check_info,linalg.decomp,_check_info,"Python Library Documentation: function _check_info in module scipy.linalg.decomp

_check_info(info, driver, positive='did not converge (LAPACK info=%d)')
    Check info return value.
",function,"('info', 'driver', 'positive')","(nan, nan, 'did not converge (LAPACK info=%d)')","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","(""(info, driver, positive='did not converge (LAPACK info=%d)')"",)"
scipy,1.1.0,scipy.linalg.decomp._check_select,linalg.decomp,_check_select,"Python Library Documentation: function _check_select in module scipy.linalg.decomp

_check_select(select, select_range, max_ev, max_len)
    Check that select is valid, convert to Fortran style.
",function,"('(select, select_range, max_ev, max_len)',)",scipy,1.1.0,scipy.linalg.decomp._check_select,linalg.decomp,_check_select,"Python Library Documentation: function _check_select in module scipy.linalg.decomp

_check_select(select, select_range, max_ev, max_len)
    Check that select is valid, convert to Fortran style.
",function,"('select', 'select_range', 'max_ev', 'max_len')","(nan, nan, nan, nan)","(nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(select, select_range, max_ev, max_len)',)"
scipy,1.1.0,scipy.linalg.decomp._compute_lwork,linalg.decomp,_compute_lwork,"Python Library Documentation: function _compute_lwork in module scipy.linalg.lapack

_compute_lwork(routine, *args, **kwargs)
    Round floating-point lwork returned by lapack to integer.
    
    Several LAPACK routines compute optimal values for LWORK, which
    they return in a floating-point variable. However, for large
    values of LWORK, single-precision floating point is not sufficient
    to hold the exact value --- some LAPACK versions (<= 3.5.0 at
    least) truncate the returned integer to single precision and in
    some cases this can be smaller than the required value.
    
    Examples
    --------
    >>> from scipy.linalg import lapack
    >>> n = 5000
    >>> s_r, s_lw = lapack.get_lapack_funcs(('sysvx', 'sysvx_lwork'))
    >>> lwork = lapack._compute_lwork(s_lw, n)
    >>> lwork
    32000
",function,"('(routine, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg.decomp._compute_lwork,linalg.decomp,_compute_lwork,"Python Library Documentation: function _compute_lwork in module scipy.linalg.lapack

_compute_lwork(routine, *args, **kwargs)
    Round floating-point lwork returned by lapack to integer.
    
    Several LAPACK routines compute optimal values for LWORK, which
    they return in a floating-point variable. However, for large
    values of LWORK, single-precision floating point is not sufficient
    to hold the exact value --- some LAPACK versions (<= 3.5.0 at
    least) truncate the returned integer to single precision and in
    some cases this can be smaller than the required value.
    
    Examples
    --------
    >>> from scipy.linalg import lapack
    >>> n = 5000
    >>> s_r, s_lw = lapack.get_lapack_funcs(('sysvx', 'sysvx_lwork'))
    >>> lwork = lapack._compute_lwork(s_lw, n)
    >>> lwork
    32000
",function,"('routine',)","(nan,)","(nan,)","('arg_info',)","('(routine, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg.decomp._datacopied,linalg.decomp,_datacopied,"Python Library Documentation: function _datacopied in module scipy.linalg.misc

_datacopied(arr, original)
    Strict check for `arr` not sharing any data with `original`,
    under the assumption that arr = asarray(original)
",function,"('(arr, original)',)",scipy,1.1.0,scipy.linalg.decomp._datacopied,linalg.decomp,_datacopied,"Python Library Documentation: function _datacopied in module scipy.linalg.misc

_datacopied(arr, original)
    Strict check for `arr` not sharing any data with `original`,
    under the assumption that arr = asarray(original)
",function,"('arr', 'original')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(arr, original)',)"
scipy,1.1.0,scipy.linalg.decomp._geneig,linalg.decomp,_geneig,"Python Library Documentation: function _geneig in module scipy.linalg.decomp

_geneig(a1, b1, left, right, overwrite_a, overwrite_b, homogeneous_eigvals)
",function,"('(a1, b1, left, right, overwrite_a, overwrite_b, homogeneous_eigvals)',)",scipy,1.1.0,scipy.linalg.decomp._geneig,linalg.decomp,_geneig,"Python Library Documentation: function _geneig in module scipy.linalg.decomp

_geneig(a1, b1, left, right, overwrite_a, overwrite_b, homogeneous_eigvals)
",function,"('a1', 'b1', 'left', 'right', 'overwrite_a', 'overwrite_b', 'homogeneous_eigvals')","(nan, nan, nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a1, b1, left, right, overwrite_a, overwrite_b, homogeneous_eigvals)',)"
scipy,1.1.0,scipy.linalg.decomp._make_complex_eigvecs,linalg.decomp,_make_complex_eigvecs,"Python Library Documentation: function _make_complex_eigvecs in module scipy.linalg.decomp

_make_complex_eigvecs(w, vin, dtype)
    Produce complex-valued eigenvectors from LAPACK DGGEV real-valued output
",function,"('(w, vin, dtype)',)",scipy,1.1.0,scipy.linalg.decomp._make_complex_eigvecs,linalg.decomp,_make_complex_eigvecs,"Python Library Documentation: function _make_complex_eigvecs in module scipy.linalg.decomp

_make_complex_eigvecs(w, vin, dtype)
    Produce complex-valued eigenvectors from LAPACK DGGEV real-valued output
",function,"('w', 'vin', 'dtype')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(w, vin, dtype)',)"
scipy,1.1.0,scipy.linalg.decomp._make_eigvals,linalg.decomp,_make_eigvals,"Python Library Documentation: function _make_eigvals in module scipy.linalg.decomp

_make_eigvals(alpha, beta, homogeneous_eigvals)
",function,"('(alpha, beta, homogeneous_eigvals)',)",scipy,1.1.0,scipy.linalg.decomp._make_eigvals,linalg.decomp,_make_eigvals,"Python Library Documentation: function _make_eigvals in module scipy.linalg.decomp

_make_eigvals(alpha, beta, homogeneous_eigvals)
",function,"('alpha', 'beta', 'homogeneous_eigvals')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(alpha, beta, homogeneous_eigvals)',)"
scipy,1.1.0,scipy.linalg.decomp.argsort,linalg.decomp,argsort,"Python Library Documentation: function argsort in module numpy.core.fromnumeric

argsort(a, axis=-1, kind='quicksort', order=None)
    Returns the indices that would sort an array.
    
    Perform an indirect sort along the given axis using the algorithm specified
    by the `kind` keyword. It returns an array of indices of the same shape as
    `a` that index data along the given axis in sorted order.
    
    Parameters
    ----------
    a : array_like
        Array to sort.
    axis : int or None, optional
        Axis along which to sort.  The default is -1 (the last axis). If None,
        the flattened array is used.
    kind : {'quicksort', 'mergesort', 'heapsort'}, optional
        Sorting algorithm.
    order : str or list of str, optional
        When `a` is an array with fields defined, this argument specifies
        which fields to compare first, second, etc.  A single field can
        be specified as a string, and not all fields need be specified,
        but unspecified fields will still be used, in the order in which
        they come up in the dtype, to break ties.
    
    Returns
    -------
    index_array : ndarray, int
        Array of indices that sort `a` along the specified axis.
        If `a` is one-dimensional, ``a[index_array]`` yields a sorted `a`.
    
    See Also
    --------
    sort : Describes sorting algorithms used.
    lexsort : Indirect stable sort with multiple keys.
    ndarray.sort : Inplace sort.
    argpartition : Indirect partial sort.
    
    Notes
    -----
    See `sort` for notes on the different sorting algorithms.
    
    As of NumPy 1.4.0 `argsort` works with real/complex arrays containing
    nan values. The enhanced sort order is documented in `sort`.
    
    Examples
    --------
    One dimensional array:
    
    >>> x = np.array([3, 1, 2])
    >>> np.argsort(x)
    array([1, 2, 0])
    
    Two-dimensional array:
    
    >>> x = np.array([[0, 3], [2, 2]])
    >>> x
    array([[0, 3],
           [2, 2]])
    
    >>> np.argsort(x, axis=0)  # sorts along first axis (down)
    array([[0, 1],
           [1, 0]])
    
    >>> np.argsort(x, axis=1)  # sorts along last axis (across)
    array([[0, 1],
           [0, 1]])
    
    Indices of the sorted elements of a N-dimensional array:
    
    >>> ind = np.unravel_index(np.argsort(x, axis=None), x.shape)
    >>> ind
    (array([0, 1, 1, 0]), array([0, 0, 1, 1]))
    >>> x[ind]  # same as np.sort(x, axis=None)
    array([0, 2, 2, 3])
    
    Sorting with keys:
    
    >>> x = np.array([(1, 0), (0, 1)], dtype=[('x', '<i4'), ('y', '<i4')])
    >>> x
    array([(1, 0), (0, 1)],
          dtype=[('x', '<i4'), ('y', '<i4')])
    
    >>> np.argsort(x, order=('x','y'))
    array([1, 0])
    
    >>> np.argsort(x, order=('y','x'))
    array([0, 1])
",function,"(""(a, axis=-1, kind='quicksort', order=None)"",)",scipy,1.1.0,scipy.linalg.decomp.argsort,linalg.decomp,argsort,"Python Library Documentation: function argsort in module numpy.core.fromnumeric

argsort(a, axis=-1, kind='quicksort', order=None)
    Returns the indices that would sort an array.
    
    Perform an indirect sort along the given axis using the algorithm specified
    by the `kind` keyword. It returns an array of indices of the same shape as
    `a` that index data along the given axis in sorted order.
    
    Parameters
    ----------
    a : array_like
        Array to sort.
    axis : int or None, optional
        Axis along which to sort.  The default is -1 (the last axis). If None,
        the flattened array is used.
    kind : {'quicksort', 'mergesort', 'heapsort'}, optional
        Sorting algorithm.
    order : str or list of str, optional
        When `a` is an array with fields defined, this argument specifies
        which fields to compare first, second, etc.  A single field can
        be specified as a string, and not all fields need be specified,
        but unspecified fields will still be used, in the order in which
        they come up in the dtype, to break ties.
    
    Returns
    -------
    index_array : ndarray, int
        Array of indices that sort `a` along the specified axis.
        If `a` is one-dimensional, ``a[index_array]`` yields a sorted `a`.
    
    See Also
    --------
    sort : Describes sorting algorithms used.
    lexsort : Indirect stable sort with multiple keys.
    ndarray.sort : Inplace sort.
    argpartition : Indirect partial sort.
    
    Notes
    -----
    See `sort` for notes on the different sorting algorithms.
    
    As of NumPy 1.4.0 `argsort` works with real/complex arrays containing
    nan values. The enhanced sort order is documented in `sort`.
    
    Examples
    --------
    One dimensional array:
    
    >>> x = np.array([3, 1, 2])
    >>> np.argsort(x)
    array([1, 2, 0])
    
    Two-dimensional array:
    
    >>> x = np.array([[0, 3], [2, 2]])
    >>> x
    array([[0, 3],
           [2, 2]])
    
    >>> np.argsort(x, axis=0)  # sorts along first axis (down)
    array([[0, 1],
           [1, 0]])
    
    >>> np.argsort(x, axis=1)  # sorts along last axis (across)
    array([[0, 1],
           [0, 1]])
    
    Indices of the sorted elements of a N-dimensional array:
    
    >>> ind = np.unravel_index(np.argsort(x, axis=None), x.shape)
    >>> ind
    (array([0, 1, 1, 0]), array([0, 0, 1, 1]))
    >>> x[ind]  # same as np.sort(x, axis=None)
    array([0, 2, 2, 3])
    
    Sorting with keys:
    
    >>> x = np.array([(1, 0), (0, 1)], dtype=[('x', '<i4'), ('y', '<i4')])
    >>> x
    array([(1, 0), (0, 1)],
          dtype=[('x', '<i4'), ('y', '<i4')])
    
    >>> np.argsort(x, order=('x','y'))
    array([1, 0])
    
    >>> np.argsort(x, order=('y','x'))
    array([0, 1])
",function,"('a', 'axis', 'kind', 'order')","(nan, -1, 'quicksort', None)","(nan, 'int', 'str', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a, axis=-1, kind='quicksort', order=None)"",)"
scipy,1.1.0,scipy.linalg.decomp.argwhere,linalg.decomp,argwhere,"Python Library Documentation: function argwhere in module numpy.core.numeric

argwhere(a)
    Find the indices of array elements that are non-zero, grouped by element.
    
    Parameters
    ----------
    a : array_like
        Input data.
    
    Returns
    -------
    index_array : ndarray
        Indices of elements that are non-zero. Indices are grouped by element.
    
    See Also
    --------
    where, nonzero
    
    Notes
    -----
    ``np.argwhere(a)`` is the same as ``np.transpose(np.nonzero(a))``.
    
    The output of ``argwhere`` is not suitable for indexing arrays.
    For this purpose use ``nonzero(a)`` instead.
    
    Examples
    --------
    >>> x = np.arange(6).reshape(2,3)
    >>> x
    array([[0, 1, 2],
           [3, 4, 5]])
    >>> np.argwhere(x>1)
    array([[0, 2],
           [1, 0],
           [1, 1],
           [1, 2]])
",function,"('(a)',)",scipy,1.1.0,scipy.linalg.decomp.argwhere,linalg.decomp,argwhere,"Python Library Documentation: function argwhere in module numpy.core.numeric

argwhere(a)
    Find the indices of array elements that are non-zero, grouped by element.
    
    Parameters
    ----------
    a : array_like
        Input data.
    
    Returns
    -------
    index_array : ndarray
        Indices of elements that are non-zero. Indices are grouped by element.
    
    See Also
    --------
    where, nonzero
    
    Notes
    -----
    ``np.argwhere(a)`` is the same as ``np.transpose(np.nonzero(a))``.
    
    The output of ``argwhere`` is not suitable for indexing arrays.
    For this purpose use ``nonzero(a)`` instead.
    
    Examples
    --------
    >>> x = np.arange(6).reshape(2,3)
    >>> x
    array([[0, 1, 2],
           [3, 4, 5]])
    >>> np.argwhere(x>1)
    array([[0, 2],
           [1, 0],
           [1, 1],
           [1, 2]])
",function,"('a',)","(nan,)","(nan,)","('arg_info',)","('(a)',)"
scipy,1.1.0,scipy.linalg.decomp.asarray,linalg.decomp,asarray,"Python Library Documentation: function asarray in module numpy.core.numeric

asarray(a, dtype=None, order=None)
    Convert the input to an array.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
        Whether to use row-major (C-style) or
        column-major (Fortran-style) memory representation.
        Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray with matching dtype and order.  If `a` is a
        subclass of ndarray, a base class ndarray is returned.
    
    See Also
    --------
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    asarray_chkfinite : Similar function which checks input for NaNs and Infs.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array:
    
    >>> a = [1, 2]
    >>> np.asarray(a)
    array([1, 2])
    
    Existing arrays are not copied:
    
    >>> a = np.array([1, 2])
    >>> np.asarray(a) is a
    True
    
    If `dtype` is set, array is copied only if dtype does not match:
    
    >>> a = np.array([1, 2], dtype=np.float32)
    >>> np.asarray(a, dtype=np.float32) is a
    True
    >>> np.asarray(a, dtype=np.float64) is a
    False
    
    Contrary to `asanyarray`, ndarray subclasses are not passed through:
    
    >>> issubclass(np.matrix, np.ndarray)
    True
    >>> a = np.matrix([[1, 2]])
    >>> np.asarray(a) is a
    False
    >>> np.asanyarray(a) is a
    True
",function,"('(a, dtype=None, order=None)',)",scipy,1.1.0,scipy.linalg.decomp.asarray,linalg.decomp,asarray,"Python Library Documentation: function asarray in module numpy.core.numeric

asarray(a, dtype=None, order=None)
    Convert the input to an array.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
        Whether to use row-major (C-style) or
        column-major (Fortran-style) memory representation.
        Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray with matching dtype and order.  If `a` is a
        subclass of ndarray, a base class ndarray is returned.
    
    See Also
    --------
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    asarray_chkfinite : Similar function which checks input for NaNs and Infs.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array:
    
    >>> a = [1, 2]
    >>> np.asarray(a)
    array([1, 2])
    
    Existing arrays are not copied:
    
    >>> a = np.array([1, 2])
    >>> np.asarray(a) is a
    True
    
    If `dtype` is set, array is copied only if dtype does not match:
    
    >>> a = np.array([1, 2], dtype=np.float32)
    >>> np.asarray(a, dtype=np.float32) is a
    True
    >>> np.asarray(a, dtype=np.float64) is a
    False
    
    Contrary to `asanyarray`, ndarray subclasses are not passed through:
    
    >>> issubclass(np.matrix, np.ndarray)
    True
    >>> a = np.matrix([[1, 2]])
    >>> np.asarray(a) is a
    False
    >>> np.asanyarray(a) is a
    True
",function,"('a', 'dtype', 'order')","(nan, None, None)","(nan, 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(a, dtype=None, order=None)',)"
scipy,1.1.0,scipy.linalg.decomp.cdf2rdf,linalg.decomp,cdf2rdf,"Python Library Documentation: function cdf2rdf in module scipy.linalg.decomp

cdf2rdf(w, v)
    Converts complex eigenvalues ``w`` and eigenvectors ``v`` to real
    eigenvalues in a block diagonal form ``wr`` and the associated real
    eigenvectors ``vr``, such that::
    
        vr @ wr = X @ vr
    
    continues to hold, where ``X`` is the original array for which ``w`` and
    ``v`` are the eigenvalues and eigenvectors.
    
    .. versionadded:: 1.1.0
    
    Parameters
    ----------
    w : (..., M) array_like
        Complex or real eigenvalues, an array or stack of arrays
    
        Conjugate pairs must not be interleaved, else the wrong result
        will be produced. So ``[1+1j, 1, 1-1j]`` will give a correct result, but
        ``[1+1j, 2+1j, 1-1j, 2-1j]`` will not.
    
    v : (..., M, M) array_like
        Complex or real eigenvectors, a square array or stack of square arrays.
    
    Returns
    -------
    wr : (..., M, M) ndarray
        Real diagonal block form of eigenvalues
    vr : (..., M, M) ndarray
        Real eigenvectors associated with ``wr``
    
    See Also
    --------
    eig : Eigenvalues and right eigenvectors for non-symmetric arrays
    rsf2csf : Convert real Schur form to complex Schur form
    
    Notes
    -----
    ``w``, ``v`` must be the eigenstructure for some *real* matrix ``X``.
    For example, obtained by ``w, v = scipy.linalg.eig(X)`` or
    ``w, v = numpy.linalg.eig(X)`` in which case ``X`` can also represent
    stacked arrays.
    
    .. versionadded:: 1.1.0
    
    Examples
    --------
    >>> X = np.array([[1, 2, 3], [0, 4, 5], [0, -5, 4]])
    >>> X
    array([[ 1,  2,  3],
           [ 0,  4,  5],
           [ 0, -5,  4]])
    
    >>> from scipy import linalg
    >>> w, v = linalg.eig(X)
    >>> w
    array([ 1.+0.j,  4.+5.j,  4.-5.j])
    >>> v
    array([[ 1.00000+0.j     , -0.01906-0.40016j, -0.01906+0.40016j],
           [ 0.00000+0.j     ,  0.00000-0.64788j,  0.00000+0.64788j],
           [ 0.00000+0.j     ,  0.64788+0.j     ,  0.64788-0.j     ]])
    
    >>> wr, vr = linalg.cdf2rdf(w, v)
    >>> wr
    array([[ 1.,  0.,  0.],
           [ 0.,  4.,  5.],
           [ 0., -5.,  4.]])
    >>> vr
    array([[ 1.     ,  0.40016, -0.01906],
           [ 0.     ,  0.64788,  0.     ],
           [ 0.     ,  0.     ,  0.64788]])
    
    >>> vr @ wr
    array([[ 1.     ,  1.69593,  1.9246 ],
           [ 0.     ,  2.59153,  3.23942],
           [ 0.     , -3.23942,  2.59153]])
    >>> X @ vr
    array([[ 1.     ,  1.69593,  1.9246 ],
           [ 0.     ,  2.59153,  3.23942],
           [ 0.     , -3.23942,  2.59153]])
",function,"('(w, v)',)",scipy,1.1.0,scipy.linalg.decomp.cdf2rdf,linalg.decomp,cdf2rdf,"Python Library Documentation: function cdf2rdf in module scipy.linalg.decomp

cdf2rdf(w, v)
    Converts complex eigenvalues ``w`` and eigenvectors ``v`` to real
    eigenvalues in a block diagonal form ``wr`` and the associated real
    eigenvectors ``vr``, such that::
    
        vr @ wr = X @ vr
    
    continues to hold, where ``X`` is the original array for which ``w`` and
    ``v`` are the eigenvalues and eigenvectors.
    
    .. versionadded:: 1.1.0
    
    Parameters
    ----------
    w : (..., M) array_like
        Complex or real eigenvalues, an array or stack of arrays
    
        Conjugate pairs must not be interleaved, else the wrong result
        will be produced. So ``[1+1j, 1, 1-1j]`` will give a correct result, but
        ``[1+1j, 2+1j, 1-1j, 2-1j]`` will not.
    
    v : (..., M, M) array_like
        Complex or real eigenvectors, a square array or stack of square arrays.
    
    Returns
    -------
    wr : (..., M, M) ndarray
        Real diagonal block form of eigenvalues
    vr : (..., M, M) ndarray
        Real eigenvectors associated with ``wr``
    
    See Also
    --------
    eig : Eigenvalues and right eigenvectors for non-symmetric arrays
    rsf2csf : Convert real Schur form to complex Schur form
    
    Notes
    -----
    ``w``, ``v`` must be the eigenstructure for some *real* matrix ``X``.
    For example, obtained by ``w, v = scipy.linalg.eig(X)`` or
    ``w, v = numpy.linalg.eig(X)`` in which case ``X`` can also represent
    stacked arrays.
    
    .. versionadded:: 1.1.0
    
    Examples
    --------
    >>> X = np.array([[1, 2, 3], [0, 4, 5], [0, -5, 4]])
    >>> X
    array([[ 1,  2,  3],
           [ 0,  4,  5],
           [ 0, -5,  4]])
    
    >>> from scipy import linalg
    >>> w, v = linalg.eig(X)
    >>> w
    array([ 1.+0.j,  4.+5.j,  4.-5.j])
    >>> v
    array([[ 1.00000+0.j     , -0.01906-0.40016j, -0.01906+0.40016j],
           [ 0.00000+0.j     ,  0.00000-0.64788j,  0.00000+0.64788j],
           [ 0.00000+0.j     ,  0.64788+0.j     ,  0.64788-0.j     ]])
    
    >>> wr, vr = linalg.cdf2rdf(w, v)
    >>> wr
    array([[ 1.,  0.,  0.],
           [ 0.,  4.,  5.],
           [ 0., -5.,  4.]])
    >>> vr
    array([[ 1.     ,  0.40016, -0.01906],
           [ 0.     ,  0.64788,  0.     ],
           [ 0.     ,  0.     ,  0.64788]])
    
    >>> vr @ wr
    array([[ 1.     ,  1.69593,  1.9246 ],
           [ 0.     ,  2.59153,  3.23942],
           [ 0.     , -3.23942,  2.59153]])
    >>> X @ vr
    array([[ 1.     ,  1.69593,  1.9246 ],
           [ 0.     ,  2.59153,  3.23942],
           [ 0.     , -3.23942,  2.59153]])
",function,"('w', 'v')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(w, v)',)"
scipy,1.1.0,scipy.linalg.decomp.eig,linalg.decomp,eig,"Python Library Documentation: function eig in module scipy.linalg.decomp

eig(a, b=None, left=False, right=True, overwrite_a=False, overwrite_b=False, check_finite=True, homogeneous_eigvals=False)
    Solve an ordinary or generalized eigenvalue problem of a square matrix.
    
    Find eigenvalues w and right or left eigenvectors of a general matrix::
    
        a   vr[:,i] = w[i]        b   vr[:,i]
        a.H vl[:,i] = w[i].conj() b.H vl[:,i]
    
    where ``.H`` is the Hermitian conjugation.
    
    Parameters
    ----------
    a : (M, M) array_like
        A complex or real matrix whose eigenvalues and eigenvectors
        will be computed.
    b : (M, M) array_like, optional
        Right-hand side matrix in a generalized eigenvalue problem.
        Default is None, identity matrix is assumed.
    left : bool, optional
        Whether to calculate and return left eigenvectors.  Default is False.
    right : bool, optional
        Whether to calculate and return right eigenvectors.  Default is True.
    overwrite_a : bool, optional
        Whether to overwrite `a`; may improve performance.  Default is False.
    overwrite_b : bool, optional
        Whether to overwrite `b`; may improve performance.  Default is False.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    homogeneous_eigvals : bool, optional
        If True, return the eigenvalues in homogeneous coordinates.
        In this case ``w`` is a (2, M) array so that::
    
            w[1,i] a vr[:,i] = w[0,i] b vr[:,i]
    
        Default is False.
    
    Returns
    -------
    w : (M,) or (2, M) double or complex ndarray
        The eigenvalues, each repeated according to its
        multiplicity. The shape is (M,) unless
        ``homogeneous_eigvals=True``.
    vl : (M, M) double or complex ndarray
        The normalized left eigenvector corresponding to the eigenvalue
        ``w[i]`` is the column vl[:,i]. Only returned if ``left=True``.
    vr : (M, M) double or complex ndarray
        The normalized right eigenvector corresponding to the eigenvalue
        ``w[i]`` is the column ``vr[:,i]``.  Only returned if ``right=True``.
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge.
    
    See Also
    --------
    eigvals : eigenvalues of general arrays
    eigh : Eigenvalues and right eigenvectors for symmetric/Hermitian arrays.
    eig_banded : eigenvalues and right eigenvectors for symmetric/Hermitian
        band matrices
    eigh_tridiagonal : eigenvalues and right eiegenvectors for
        symmetric/Hermitian tridiagonal matrices
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.array([[0., -1.], [1., 0.]])
    >>> linalg.eigvals(a)
    array([0.+1.j, 0.-1.j])
    
    >>> b = np.array([[0., 1.], [1., 1.]])
    >>> linalg.eigvals(a, b)
    array([ 1.+0.j, -1.+0.j])
    
    >>> a = np.array([[3., 0., 0.], [0., 8., 0.], [0., 0., 7.]])
    >>> linalg.eigvals(a, homogeneous_eigvals=True)
    array([[3.+0.j, 8.+0.j, 7.+0.j],
           [1.+0.j, 1.+0.j, 1.+0.j]])
    
    >>> a = np.array([[0., -1.], [1., 0.]])
    >>> linalg.eigvals(a) == linalg.eig(a)[0]
    array([ True,  True])
    >>> linalg.eig(a, left=True, right=False)[1] # normalized left eigenvector
    array([[-0.70710678+0.j        , -0.70710678-0.j        ],
           [-0.        +0.70710678j, -0.        -0.70710678j]])
    >>> linalg.eig(a, left=False, right=True)[1] # normalized right eigenvector
    array([[0.70710678+0.j        , 0.70710678-0.j        ],
           [0.        -0.70710678j, 0.        +0.70710678j]])
",function,"('(a, b=None, left=False, right=True, overwrite_a=False, overwrite_b=False, check_finite=True, homogeneous_eigvals=False)',)",scipy,1.1.0,scipy.linalg.decomp.eig,linalg.decomp,eig,"Python Library Documentation: function eig in module scipy.linalg.decomp

eig(a, b=None, left=False, right=True, overwrite_a=False, overwrite_b=False, check_finite=True, homogeneous_eigvals=False)
    Solve an ordinary or generalized eigenvalue problem of a square matrix.
    
    Find eigenvalues w and right or left eigenvectors of a general matrix::
    
        a   vr[:,i] = w[i]        b   vr[:,i]
        a.H vl[:,i] = w[i].conj() b.H vl[:,i]
    
    where ``.H`` is the Hermitian conjugation.
    
    Parameters
    ----------
    a : (M, M) array_like
        A complex or real matrix whose eigenvalues and eigenvectors
        will be computed.
    b : (M, M) array_like, optional
        Right-hand side matrix in a generalized eigenvalue problem.
        Default is None, identity matrix is assumed.
    left : bool, optional
        Whether to calculate and return left eigenvectors.  Default is False.
    right : bool, optional
        Whether to calculate and return right eigenvectors.  Default is True.
    overwrite_a : bool, optional
        Whether to overwrite `a`; may improve performance.  Default is False.
    overwrite_b : bool, optional
        Whether to overwrite `b`; may improve performance.  Default is False.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    homogeneous_eigvals : bool, optional
        If True, return the eigenvalues in homogeneous coordinates.
        In this case ``w`` is a (2, M) array so that::
    
            w[1,i] a vr[:,i] = w[0,i] b vr[:,i]
    
        Default is False.
    
    Returns
    -------
    w : (M,) or (2, M) double or complex ndarray
        The eigenvalues, each repeated according to its
        multiplicity. The shape is (M,) unless
        ``homogeneous_eigvals=True``.
    vl : (M, M) double or complex ndarray
        The normalized left eigenvector corresponding to the eigenvalue
        ``w[i]`` is the column vl[:,i]. Only returned if ``left=True``.
    vr : (M, M) double or complex ndarray
        The normalized right eigenvector corresponding to the eigenvalue
        ``w[i]`` is the column ``vr[:,i]``.  Only returned if ``right=True``.
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge.
    
    See Also
    --------
    eigvals : eigenvalues of general arrays
    eigh : Eigenvalues and right eigenvectors for symmetric/Hermitian arrays.
    eig_banded : eigenvalues and right eigenvectors for symmetric/Hermitian
        band matrices
    eigh_tridiagonal : eigenvalues and right eiegenvectors for
        symmetric/Hermitian tridiagonal matrices
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.array([[0., -1.], [1., 0.]])
    >>> linalg.eigvals(a)
    array([0.+1.j, 0.-1.j])
    
    >>> b = np.array([[0., 1.], [1., 1.]])
    >>> linalg.eigvals(a, b)
    array([ 1.+0.j, -1.+0.j])
    
    >>> a = np.array([[3., 0., 0.], [0., 8., 0.], [0., 0., 7.]])
    >>> linalg.eigvals(a, homogeneous_eigvals=True)
    array([[3.+0.j, 8.+0.j, 7.+0.j],
           [1.+0.j, 1.+0.j, 1.+0.j]])
    
    >>> a = np.array([[0., -1.], [1., 0.]])
    >>> linalg.eigvals(a) == linalg.eig(a)[0]
    array([ True,  True])
    >>> linalg.eig(a, left=True, right=False)[1] # normalized left eigenvector
    array([[-0.70710678+0.j        , -0.70710678-0.j        ],
           [-0.        +0.70710678j, -0.        -0.70710678j]])
    >>> linalg.eig(a, left=False, right=True)[1] # normalized right eigenvector
    array([[0.70710678+0.j        , 0.70710678-0.j        ],
           [0.        -0.70710678j, 0.        +0.70710678j]])
",function,"('a', 'b', 'left', 'right', 'overwrite_a', 'overwrite_b', 'check_finite', 'homogeneous_eigvals')","(nan, None, False, True, False, False, True, False)","(nan, 'NoneType', 'bool', 'bool', 'bool', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, b=None, left=False, right=True, overwrite_a=False, overwrite_b=False, check_finite=True, homogeneous_eigvals=False)',)"
scipy,1.1.0,scipy.linalg.decomp.eig_banded,linalg.decomp,eig_banded,"Python Library Documentation: function eig_banded in module scipy.linalg.decomp

eig_banded(a_band, lower=False, eigvals_only=False, overwrite_a_band=False, select='a', select_range=None, max_ev=0, check_finite=True)
    Solve real symmetric or complex hermitian band matrix eigenvalue problem.
    
    Find eigenvalues w and optionally right eigenvectors v of a::
    
        a v[:,i] = w[i] v[:,i]
        v.H v    = identity
    
    The matrix a is stored in a_band either in lower diagonal or upper
    diagonal ordered form:
    
        a_band[u + i - j, j] == a[i,j]        (if upper form; i <= j)
        a_band[    i - j, j] == a[i,j]        (if lower form; i >= j)
    
    where u is the number of bands above the diagonal.
    
    Example of a_band (shape of a is (6,6), u=2)::
    
        upper form:
        *   *   a02 a13 a24 a35
        *   a01 a12 a23 a34 a45
        a00 a11 a22 a33 a44 a55
    
        lower form:
        a00 a11 a22 a33 a44 a55
        a10 a21 a32 a43 a54 *
        a20 a31 a42 a53 *   *
    
    Cells marked with * are not used.
    
    Parameters
    ----------
    a_band : (u+1, M) array_like
        The bands of the M by M matrix a.
    lower : bool, optional
        Is the matrix in the lower form. (Default is upper form)
    eigvals_only : bool, optional
        Compute only the eigenvalues and no eigenvectors.
        (Default: calculate also eigenvectors)
    overwrite_a_band : bool, optional
        Discard data in a_band (may enhance performance)
    select : {'a', 'v', 'i'}, optional
        Which eigenvalues to calculate
    
        ======  ========================================
        select  calculated
        ======  ========================================
        'a'     All eigenvalues
        'v'     Eigenvalues in the interval (min, max]
        'i'     Eigenvalues with indices min <= i <= max
        ======  ========================================
    select_range : (min, max), optional
        Range of selected eigenvalues
    max_ev : int, optional
        For select=='v', maximum number of eigenvalues expected.
        For other values of select, has no meaning.
    
        In doubt, leave this parameter untouched.
    
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    w : (M,) ndarray
        The eigenvalues, in ascending order, each repeated according to its
        multiplicity.
    v : (M, M) float or complex ndarray
        The normalized eigenvector corresponding to the eigenvalue w[i] is
        the column v[:,i].
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge.
    
    See Also
    --------
    eigvals_banded : eigenvalues for symmetric/Hermitian band matrices
    eig : eigenvalues and right eigenvectors of general arrays.
    eigh : eigenvalues and right eigenvectors for symmetric/Hermitian arrays
    eigh_tridiagonal : eigenvalues and right eiegenvectors for
        symmetric/Hermitian tridiagonal matrices
    
    Examples
    --------
    >>> from scipy.linalg import eig_banded
    >>> A = np.array([[1, 5, 2, 0], [5, 2, 5, 2], [2, 5, 3, 5], [0, 2, 5, 4]])
    >>> Ab = np.array([[1, 2, 3, 4], [5, 5, 5, 0], [2, 2, 0, 0]])
    >>> w, v = eig_banded(Ab, lower=True)
    >>> np.allclose(A @ v - v @ np.diag(w), np.zeros((4, 4)))
    True
    >>> w = eig_banded(Ab, lower=True, eigvals_only=True)
    >>> w
    array([-4.26200532, -2.22987175,  3.95222349, 12.53965359])
    
    Request only the eigenvalues between ``[-3, 4]``
    
    >>> w, v = eig_banded(Ab, lower=True, select='v', select_range=[-3, 4])
    >>> w
    array([-2.22987175,  3.95222349])
",function,"(""(a_band, lower=False, eigvals_only=False, overwrite_a_band=False, select='a', select_range=None, max_ev=0, check_finite=True)"",)",scipy,1.1.0,scipy.linalg.decomp.eig_banded,linalg.decomp,eig_banded,"Python Library Documentation: function eig_banded in module scipy.linalg.decomp

eig_banded(a_band, lower=False, eigvals_only=False, overwrite_a_band=False, select='a', select_range=None, max_ev=0, check_finite=True)
    Solve real symmetric or complex hermitian band matrix eigenvalue problem.
    
    Find eigenvalues w and optionally right eigenvectors v of a::
    
        a v[:,i] = w[i] v[:,i]
        v.H v    = identity
    
    The matrix a is stored in a_band either in lower diagonal or upper
    diagonal ordered form:
    
        a_band[u + i - j, j] == a[i,j]        (if upper form; i <= j)
        a_band[    i - j, j] == a[i,j]        (if lower form; i >= j)
    
    where u is the number of bands above the diagonal.
    
    Example of a_band (shape of a is (6,6), u=2)::
    
        upper form:
        *   *   a02 a13 a24 a35
        *   a01 a12 a23 a34 a45
        a00 a11 a22 a33 a44 a55
    
        lower form:
        a00 a11 a22 a33 a44 a55
        a10 a21 a32 a43 a54 *
        a20 a31 a42 a53 *   *
    
    Cells marked with * are not used.
    
    Parameters
    ----------
    a_band : (u+1, M) array_like
        The bands of the M by M matrix a.
    lower : bool, optional
        Is the matrix in the lower form. (Default is upper form)
    eigvals_only : bool, optional
        Compute only the eigenvalues and no eigenvectors.
        (Default: calculate also eigenvectors)
    overwrite_a_band : bool, optional
        Discard data in a_band (may enhance performance)
    select : {'a', 'v', 'i'}, optional
        Which eigenvalues to calculate
    
        ======  ========================================
        select  calculated
        ======  ========================================
        'a'     All eigenvalues
        'v'     Eigenvalues in the interval (min, max]
        'i'     Eigenvalues with indices min <= i <= max
        ======  ========================================
    select_range : (min, max), optional
        Range of selected eigenvalues
    max_ev : int, optional
        For select=='v', maximum number of eigenvalues expected.
        For other values of select, has no meaning.
    
        In doubt, leave this parameter untouched.
    
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    w : (M,) ndarray
        The eigenvalues, in ascending order, each repeated according to its
        multiplicity.
    v : (M, M) float or complex ndarray
        The normalized eigenvector corresponding to the eigenvalue w[i] is
        the column v[:,i].
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge.
    
    See Also
    --------
    eigvals_banded : eigenvalues for symmetric/Hermitian band matrices
    eig : eigenvalues and right eigenvectors of general arrays.
    eigh : eigenvalues and right eigenvectors for symmetric/Hermitian arrays
    eigh_tridiagonal : eigenvalues and right eiegenvectors for
        symmetric/Hermitian tridiagonal matrices
    
    Examples
    --------
    >>> from scipy.linalg import eig_banded
    >>> A = np.array([[1, 5, 2, 0], [5, 2, 5, 2], [2, 5, 3, 5], [0, 2, 5, 4]])
    >>> Ab = np.array([[1, 2, 3, 4], [5, 5, 5, 0], [2, 2, 0, 0]])
    >>> w, v = eig_banded(Ab, lower=True)
    >>> np.allclose(A @ v - v @ np.diag(w), np.zeros((4, 4)))
    True
    >>> w = eig_banded(Ab, lower=True, eigvals_only=True)
    >>> w
    array([-4.26200532, -2.22987175,  3.95222349, 12.53965359])
    
    Request only the eigenvalues between ``[-3, 4]``
    
    >>> w, v = eig_banded(Ab, lower=True, select='v', select_range=[-3, 4])
    >>> w
    array([-2.22987175,  3.95222349])
",function,"('a_band', 'lower', 'eigvals_only', 'overwrite_a_band', 'select', 'select_range', 'max_ev', 'check_finite')","(nan, False, False, False, 'a', None, 0, True)","(nan, 'bool', 'bool', 'bool', 'str', 'NoneType', 'int', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a_band, lower=False, eigvals_only=False, overwrite_a_band=False, select='a', select_range=None, max_ev=0, check_finite=True)"",)"
scipy,1.1.0,scipy.linalg.decomp.eigh,linalg.decomp,eigh,"Python Library Documentation: function eigh in module scipy.linalg.decomp

eigh(a, b=None, lower=True, eigvals_only=False, overwrite_a=False, overwrite_b=False, turbo=True, eigvals=None, type=1, check_finite=True)
    Solve an ordinary or generalized eigenvalue problem for a complex
    Hermitian or real symmetric matrix.
    
    Find eigenvalues w and optionally eigenvectors v of matrix `a`, where
    `b` is positive definite::
    
                      a v[:,i] = w[i] b v[:,i]
        v[i,:].conj() a v[:,i] = w[i]
        v[i,:].conj() b v[:,i] = 1
    
    Parameters
    ----------
    a : (M, M) array_like
        A complex Hermitian or real symmetric matrix whose eigenvalues and
        eigenvectors will be computed.
    b : (M, M) array_like, optional
        A complex Hermitian or real symmetric definite positive matrix in.
        If omitted, identity matrix is assumed.
    lower : bool, optional
        Whether the pertinent array data is taken from the lower or upper
        triangle of `a`. (Default: lower)
    eigvals_only : bool, optional
        Whether to calculate only eigenvalues and no eigenvectors.
        (Default: both are calculated)
    turbo : bool, optional
        Use divide and conquer algorithm (faster but expensive in memory,
        only for generalized eigenvalue problem and if eigvals=None)
    eigvals : tuple (lo, hi), optional
        Indexes of the smallest and largest (in ascending order) eigenvalues
        and corresponding eigenvectors to be returned: 0 <= lo <= hi <= M-1.
        If omitted, all eigenvalues and eigenvectors are returned.
    type : int, optional
        Specifies the problem type to be solved:
    
           type = 1: a   v[:,i] = w[i] b v[:,i]
    
           type = 2: a b v[:,i] = w[i]   v[:,i]
    
           type = 3: b a v[:,i] = w[i]   v[:,i]
    overwrite_a : bool, optional
        Whether to overwrite data in `a` (may improve performance)
    overwrite_b : bool, optional
        Whether to overwrite data in `b` (may improve performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    w : (N,) float ndarray
        The N (1<=N<=M) selected eigenvalues, in ascending order, each
        repeated according to its multiplicity.
    v : (M, N) complex ndarray
        (if eigvals_only == False)
    
        The normalized selected eigenvector corresponding to the
        eigenvalue w[i] is the column v[:,i].
    
        Normalization:
    
            type 1 and 3: v.conj() a      v  = w
    
            type 2: inv(v).conj() a  inv(v) = w
    
            type = 1 or 2: v.conj() b      v  = I
    
            type = 3: v.conj() inv(b) v  = I
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge,
        an error occurred, or b matrix is not definite positive. Note that
        if input matrices are not symmetric or hermitian, no error is reported
        but results will be wrong.
    
    See Also
    --------
    eigvalsh : eigenvalues of symmetric or Hermitian arrays
    eig : eigenvalues and right eigenvectors for non-symmetric arrays
    eigh : eigenvalues and right eigenvectors for symmetric/Hermitian arrays
    eigh_tridiagonal : eigenvalues and right eiegenvectors for
        symmetric/Hermitian tridiagonal matrices
    
    Notes
    -----
    This function does not check the input array for being hermitian/symmetric
    in order to allow for representing arrays with only their upper/lower
    triangular parts.
    
    Examples
    --------
    >>> from scipy.linalg import eigh
    >>> A = np.array([[6, 3, 1, 5], [3, 0, 5, 1], [1, 5, 6, 2], [5, 1, 2, 2]])
    >>> w, v = eigh(A)
    >>> np.allclose(A @ v - v @ np.diag(w), np.zeros((4, 4)))
    True
",function,"('(a, b=None, lower=True, eigvals_only=False, overwrite_a=False, overwrite_b=False, turbo=True, eigvals=None, type=1, check_finite=True)',)",scipy,1.1.0,scipy.linalg.decomp.eigh,linalg.decomp,eigh,"Python Library Documentation: function eigh in module scipy.linalg.decomp

eigh(a, b=None, lower=True, eigvals_only=False, overwrite_a=False, overwrite_b=False, turbo=True, eigvals=None, type=1, check_finite=True)
    Solve an ordinary or generalized eigenvalue problem for a complex
    Hermitian or real symmetric matrix.
    
    Find eigenvalues w and optionally eigenvectors v of matrix `a`, where
    `b` is positive definite::
    
                      a v[:,i] = w[i] b v[:,i]
        v[i,:].conj() a v[:,i] = w[i]
        v[i,:].conj() b v[:,i] = 1
    
    Parameters
    ----------
    a : (M, M) array_like
        A complex Hermitian or real symmetric matrix whose eigenvalues and
        eigenvectors will be computed.
    b : (M, M) array_like, optional
        A complex Hermitian or real symmetric definite positive matrix in.
        If omitted, identity matrix is assumed.
    lower : bool, optional
        Whether the pertinent array data is taken from the lower or upper
        triangle of `a`. (Default: lower)
    eigvals_only : bool, optional
        Whether to calculate only eigenvalues and no eigenvectors.
        (Default: both are calculated)
    turbo : bool, optional
        Use divide and conquer algorithm (faster but expensive in memory,
        only for generalized eigenvalue problem and if eigvals=None)
    eigvals : tuple (lo, hi), optional
        Indexes of the smallest and largest (in ascending order) eigenvalues
        and corresponding eigenvectors to be returned: 0 <= lo <= hi <= M-1.
        If omitted, all eigenvalues and eigenvectors are returned.
    type : int, optional
        Specifies the problem type to be solved:
    
           type = 1: a   v[:,i] = w[i] b v[:,i]
    
           type = 2: a b v[:,i] = w[i]   v[:,i]
    
           type = 3: b a v[:,i] = w[i]   v[:,i]
    overwrite_a : bool, optional
        Whether to overwrite data in `a` (may improve performance)
    overwrite_b : bool, optional
        Whether to overwrite data in `b` (may improve performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    w : (N,) float ndarray
        The N (1<=N<=M) selected eigenvalues, in ascending order, each
        repeated according to its multiplicity.
    v : (M, N) complex ndarray
        (if eigvals_only == False)
    
        The normalized selected eigenvector corresponding to the
        eigenvalue w[i] is the column v[:,i].
    
        Normalization:
    
            type 1 and 3: v.conj() a      v  = w
    
            type 2: inv(v).conj() a  inv(v) = w
    
            type = 1 or 2: v.conj() b      v  = I
    
            type = 3: v.conj() inv(b) v  = I
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge,
        an error occurred, or b matrix is not definite positive. Note that
        if input matrices are not symmetric or hermitian, no error is reported
        but results will be wrong.
    
    See Also
    --------
    eigvalsh : eigenvalues of symmetric or Hermitian arrays
    eig : eigenvalues and right eigenvectors for non-symmetric arrays
    eigh : eigenvalues and right eigenvectors for symmetric/Hermitian arrays
    eigh_tridiagonal : eigenvalues and right eiegenvectors for
        symmetric/Hermitian tridiagonal matrices
    
    Notes
    -----
    This function does not check the input array for being hermitian/symmetric
    in order to allow for representing arrays with only their upper/lower
    triangular parts.
    
    Examples
    --------
    >>> from scipy.linalg import eigh
    >>> A = np.array([[6, 3, 1, 5], [3, 0, 5, 1], [1, 5, 6, 2], [5, 1, 2, 2]])
    >>> w, v = eigh(A)
    >>> np.allclose(A @ v - v @ np.diag(w), np.zeros((4, 4)))
    True
",function,"('a', 'b', 'lower', 'eigvals_only', 'overwrite_a', 'overwrite_b', 'turbo', 'eigvals', 'type', 'check_finite')","(nan, None, True, False, False, False, True, None, 1, True)","(nan, 'NoneType', 'bool', 'bool', 'bool', 'bool', 'bool', 'NoneType', 'int', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, b=None, lower=True, eigvals_only=False, overwrite_a=False, overwrite_b=False, turbo=True, eigvals=None, type=1, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.decomp.eigh_tridiagonal,linalg.decomp,eigh_tridiagonal,"Python Library Documentation: function eigh_tridiagonal in module scipy.linalg.decomp

eigh_tridiagonal(d, e, eigvals_only=False, select='a', select_range=None, check_finite=True, tol=0.0, lapack_driver='auto')
    Solve eigenvalue problem for a real symmetric tridiagonal matrix.
    
    Find eigenvalues `w` and optionally right eigenvectors `v` of ``a``::
    
        a v[:,i] = w[i] v[:,i]
        v.H v    = identity
    
    For a real symmetric matrix ``a`` with diagonal elements `d` and
    off-diagonal elements `e`.
    
    Parameters
    ----------
    d : ndarray, shape (ndim,)
        The diagonal elements of the array.
    e : ndarray, shape (ndim-1,)
        The off-diagonal elements of the array.
    select : {'a', 'v', 'i'}, optional
        Which eigenvalues to calculate
    
        ======  ========================================
        select  calculated
        ======  ========================================
        'a'     All eigenvalues
        'v'     Eigenvalues in the interval (min, max]
        'i'     Eigenvalues with indices min <= i <= max
        ======  ========================================
    select_range : (min, max), optional
        Range of selected eigenvalues
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    tol : float
        The absolute tolerance to which each eigenvalue is required
        (only used when 'stebz' is the `lapack_driver`).
        An eigenvalue (or cluster) is considered to have converged if it
        lies in an interval of this width. If <= 0. (default),
        the value ``eps*|a|`` is used where eps is the machine precision,
        and ``|a|`` is the 1-norm of the matrix ``a``.
    lapack_driver : str
        LAPACK function to use, can be 'auto', 'stemr', 'stebz', 'sterf',
        or 'stev'. When 'auto' (default), it will use 'stemr' if ``select='a'``
        and 'stebz' otherwise. When 'stebz' is used to find the eigenvalues and
        ``eigvals_only=False``, then a second LAPACK call (to ``?STEIN``) is
        used to find the corresponding eigenvectors. 'sterf' can only be
        used when ``eigvals_only=True`` and ``select='a'``. 'stev' can only
        be used when ``select='a'``.
    
    Returns
    -------
    w : (M,) ndarray
        The eigenvalues, in ascending order, each repeated according to its
        multiplicity.
    v : (M, M) ndarray
        The normalized eigenvector corresponding to the eigenvalue ``w[i]`` is
        the column ``v[:,i]``.
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge.
    
    See Also
    --------
    eigvalsh_tridiagonal : eigenvalues of symmetric/Hermitian tridiagonal
        matrices
    eig : eigenvalues and right eigenvectors for non-symmetric arrays
    eigh : eigenvalues and right eigenvectors for symmetric/Hermitian arrays
    eig_banded : eigenvalues and right eigenvectors for symmetric/Hermitian
        band matrices
    
    Notes
    -----
    This function makes use of LAPACK ``S/DSTEMR`` routines.
    
    Examples
    --------
    >>> from scipy.linalg import eigh_tridiagonal
    >>> d = 3*np.ones(4)
    >>> e = -1*np.ones(3)
    >>> w, v = eigh_tridiagonal(d, e)
    >>> A = np.diag(d) + np.diag(e, k=1) + np.diag(e, k=-1)
    >>> np.allclose(A @ v - v @ np.diag(w), np.zeros((4, 4)))
    True
",function,"(""(d, e, eigvals_only=False, select='a', select_range=None, check_finite=True, tol=0.0, lapack_driver='auto')"",)",scipy,1.1.0,scipy.linalg.decomp.eigh_tridiagonal,linalg.decomp,eigh_tridiagonal,"Python Library Documentation: function eigh_tridiagonal in module scipy.linalg.decomp

eigh_tridiagonal(d, e, eigvals_only=False, select='a', select_range=None, check_finite=True, tol=0.0, lapack_driver='auto')
    Solve eigenvalue problem for a real symmetric tridiagonal matrix.
    
    Find eigenvalues `w` and optionally right eigenvectors `v` of ``a``::
    
        a v[:,i] = w[i] v[:,i]
        v.H v    = identity
    
    For a real symmetric matrix ``a`` with diagonal elements `d` and
    off-diagonal elements `e`.
    
    Parameters
    ----------
    d : ndarray, shape (ndim,)
        The diagonal elements of the array.
    e : ndarray, shape (ndim-1,)
        The off-diagonal elements of the array.
    select : {'a', 'v', 'i'}, optional
        Which eigenvalues to calculate
    
        ======  ========================================
        select  calculated
        ======  ========================================
        'a'     All eigenvalues
        'v'     Eigenvalues in the interval (min, max]
        'i'     Eigenvalues with indices min <= i <= max
        ======  ========================================
    select_range : (min, max), optional
        Range of selected eigenvalues
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    tol : float
        The absolute tolerance to which each eigenvalue is required
        (only used when 'stebz' is the `lapack_driver`).
        An eigenvalue (or cluster) is considered to have converged if it
        lies in an interval of this width. If <= 0. (default),
        the value ``eps*|a|`` is used where eps is the machine precision,
        and ``|a|`` is the 1-norm of the matrix ``a``.
    lapack_driver : str
        LAPACK function to use, can be 'auto', 'stemr', 'stebz', 'sterf',
        or 'stev'. When 'auto' (default), it will use 'stemr' if ``select='a'``
        and 'stebz' otherwise. When 'stebz' is used to find the eigenvalues and
        ``eigvals_only=False``, then a second LAPACK call (to ``?STEIN``) is
        used to find the corresponding eigenvectors. 'sterf' can only be
        used when ``eigvals_only=True`` and ``select='a'``. 'stev' can only
        be used when ``select='a'``.
    
    Returns
    -------
    w : (M,) ndarray
        The eigenvalues, in ascending order, each repeated according to its
        multiplicity.
    v : (M, M) ndarray
        The normalized eigenvector corresponding to the eigenvalue ``w[i]`` is
        the column ``v[:,i]``.
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge.
    
    See Also
    --------
    eigvalsh_tridiagonal : eigenvalues of symmetric/Hermitian tridiagonal
        matrices
    eig : eigenvalues and right eigenvectors for non-symmetric arrays
    eigh : eigenvalues and right eigenvectors for symmetric/Hermitian arrays
    eig_banded : eigenvalues and right eigenvectors for symmetric/Hermitian
        band matrices
    
    Notes
    -----
    This function makes use of LAPACK ``S/DSTEMR`` routines.
    
    Examples
    --------
    >>> from scipy.linalg import eigh_tridiagonal
    >>> d = 3*np.ones(4)
    >>> e = -1*np.ones(3)
    >>> w, v = eigh_tridiagonal(d, e)
    >>> A = np.diag(d) + np.diag(e, k=1) + np.diag(e, k=-1)
    >>> np.allclose(A @ v - v @ np.diag(w), np.zeros((4, 4)))
    True
",function,"('d', 'e', 'eigvals_only', 'select', 'select_range', 'check_finite', 'tol', 'lapack_driver')","(nan, nan, False, 'a', None, True, 0.0, 'auto')","(nan, nan, 'bool', 'str', 'NoneType', 'bool', 'float', 'str')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(d, e, eigvals_only=False, select='a', select_range=None, check_finite=True, tol=0.0, lapack_driver='auto')"",)"
scipy,1.1.0,scipy.linalg.decomp.eigvals,linalg.decomp,eigvals,"Python Library Documentation: function eigvals in module scipy.linalg.decomp

eigvals(a, b=None, overwrite_a=False, check_finite=True, homogeneous_eigvals=False)
    Compute eigenvalues from an ordinary or generalized eigenvalue problem.
    
    Find eigenvalues of a general matrix::
    
        a   vr[:,i] = w[i]        b   vr[:,i]
    
    Parameters
    ----------
    a : (M, M) array_like
        A complex or real matrix whose eigenvalues and eigenvectors
        will be computed.
    b : (M, M) array_like, optional
        Right-hand side matrix in a generalized eigenvalue problem.
        If omitted, identity matrix is assumed.
    overwrite_a : bool, optional
        Whether to overwrite data in a (may improve performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities
        or NaNs.
    homogeneous_eigvals : bool, optional
        If True, return the eigenvalues in homogeneous coordinates.
        In this case ``w`` is a (2, M) array so that::
    
            w[1,i] a vr[:,i] = w[0,i] b vr[:,i]
    
        Default is False.
    
    Returns
    -------
    w : (M,) or (2, M) double or complex ndarray
        The eigenvalues, each repeated according to its multiplicity
        but not in any specific order. The shape is (M,) unless
        ``homogeneous_eigvals=True``.
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge
    
    See Also
    --------
    eig : eigenvalues and right eigenvectors of general arrays.
    eigvalsh : eigenvalues of symmetric or Hermitian arrays
    eigvals_banded : eigenvalues for symmetric/Hermitian band matrices
    eigvalsh_tridiagonal : eigenvalues of symmetric/Hermitian tridiagonal
        matrices
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.array([[0., -1.], [1., 0.]])
    >>> linalg.eigvals(a)
    array([0.+1.j, 0.-1.j])
    
    >>> b = np.array([[0., 1.], [1., 1.]])
    >>> linalg.eigvals(a, b)
    array([ 1.+0.j, -1.+0.j])
    
    >>> a = np.array([[3., 0., 0.], [0., 8., 0.], [0., 0., 7.]])
    >>> linalg.eigvals(a, homogeneous_eigvals=True)
    array([[3.+0.j, 8.+0.j, 7.+0.j],
           [1.+0.j, 1.+0.j, 1.+0.j]])
",function,"('(a, b=None, overwrite_a=False, check_finite=True, homogeneous_eigvals=False)',)",scipy,1.1.0,scipy.linalg.decomp.eigvals,linalg.decomp,eigvals,"Python Library Documentation: function eigvals in module scipy.linalg.decomp

eigvals(a, b=None, overwrite_a=False, check_finite=True, homogeneous_eigvals=False)
    Compute eigenvalues from an ordinary or generalized eigenvalue problem.
    
    Find eigenvalues of a general matrix::
    
        a   vr[:,i] = w[i]        b   vr[:,i]
    
    Parameters
    ----------
    a : (M, M) array_like
        A complex or real matrix whose eigenvalues and eigenvectors
        will be computed.
    b : (M, M) array_like, optional
        Right-hand side matrix in a generalized eigenvalue problem.
        If omitted, identity matrix is assumed.
    overwrite_a : bool, optional
        Whether to overwrite data in a (may improve performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities
        or NaNs.
    homogeneous_eigvals : bool, optional
        If True, return the eigenvalues in homogeneous coordinates.
        In this case ``w`` is a (2, M) array so that::
    
            w[1,i] a vr[:,i] = w[0,i] b vr[:,i]
    
        Default is False.
    
    Returns
    -------
    w : (M,) or (2, M) double or complex ndarray
        The eigenvalues, each repeated according to its multiplicity
        but not in any specific order. The shape is (M,) unless
        ``homogeneous_eigvals=True``.
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge
    
    See Also
    --------
    eig : eigenvalues and right eigenvectors of general arrays.
    eigvalsh : eigenvalues of symmetric or Hermitian arrays
    eigvals_banded : eigenvalues for symmetric/Hermitian band matrices
    eigvalsh_tridiagonal : eigenvalues of symmetric/Hermitian tridiagonal
        matrices
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.array([[0., -1.], [1., 0.]])
    >>> linalg.eigvals(a)
    array([0.+1.j, 0.-1.j])
    
    >>> b = np.array([[0., 1.], [1., 1.]])
    >>> linalg.eigvals(a, b)
    array([ 1.+0.j, -1.+0.j])
    
    >>> a = np.array([[3., 0., 0.], [0., 8., 0.], [0., 0., 7.]])
    >>> linalg.eigvals(a, homogeneous_eigvals=True)
    array([[3.+0.j, 8.+0.j, 7.+0.j],
           [1.+0.j, 1.+0.j, 1.+0.j]])
",function,"('a', 'b', 'overwrite_a', 'check_finite', 'homogeneous_eigvals')","(nan, None, False, True, False)","(nan, 'NoneType', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, b=None, overwrite_a=False, check_finite=True, homogeneous_eigvals=False)',)"
scipy,1.1.0,scipy.linalg.decomp.eigvals_banded,linalg.decomp,eigvals_banded,"Python Library Documentation: function eigvals_banded in module scipy.linalg.decomp

eigvals_banded(a_band, lower=False, overwrite_a_band=False, select='a', select_range=None, check_finite=True)
    Solve real symmetric or complex hermitian band matrix eigenvalue problem.
    
    Find eigenvalues w of a::
    
        a v[:,i] = w[i] v[:,i]
        v.H v    = identity
    
    The matrix a is stored in a_band either in lower diagonal or upper
    diagonal ordered form:
    
        a_band[u + i - j, j] == a[i,j]        (if upper form; i <= j)
        a_band[    i - j, j] == a[i,j]        (if lower form; i >= j)
    
    where u is the number of bands above the diagonal.
    
    Example of a_band (shape of a is (6,6), u=2)::
    
        upper form:
        *   *   a02 a13 a24 a35
        *   a01 a12 a23 a34 a45
        a00 a11 a22 a33 a44 a55
    
        lower form:
        a00 a11 a22 a33 a44 a55
        a10 a21 a32 a43 a54 *
        a20 a31 a42 a53 *   *
    
    Cells marked with * are not used.
    
    Parameters
    ----------
    a_band : (u+1, M) array_like
        The bands of the M by M matrix a.
    lower : bool, optional
        Is the matrix in the lower form. (Default is upper form)
    overwrite_a_band : bool, optional
        Discard data in a_band (may enhance performance)
    select : {'a', 'v', 'i'}, optional
        Which eigenvalues to calculate
    
        ======  ========================================
        select  calculated
        ======  ========================================
        'a'     All eigenvalues
        'v'     Eigenvalues in the interval (min, max]
        'i'     Eigenvalues with indices min <= i <= max
        ======  ========================================
    select_range : (min, max), optional
        Range of selected eigenvalues
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    w : (M,) ndarray
        The eigenvalues, in ascending order, each repeated according to its
        multiplicity.
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge.
    
    See Also
    --------
    eig_banded : eigenvalues and right eigenvectors for symmetric/Hermitian
        band matrices
    eigvalsh_tridiagonal : eigenvalues of symmetric/Hermitian tridiagonal
        matrices
    eigvals : eigenvalues of general arrays
    eigh : eigenvalues and right eigenvectors for symmetric/Hermitian arrays
    eig : eigenvalues and right eigenvectors for non-symmetric arrays
    
    Examples
    --------
    >>> from scipy.linalg import eigvals_banded
    >>> A = np.array([[1, 5, 2, 0], [5, 2, 5, 2], [2, 5, 3, 5], [0, 2, 5, 4]])
    >>> Ab = np.array([[1, 2, 3, 4], [5, 5, 5, 0], [2, 2, 0, 0]])
    >>> w = eigvals_banded(Ab, lower=True)
    >>> w
    array([-4.26200532, -2.22987175,  3.95222349, 12.53965359])
",function,"(""(a_band, lower=False, overwrite_a_band=False, select='a', select_range=None, check_finite=True)"",)",scipy,1.1.0,scipy.linalg.decomp.eigvals_banded,linalg.decomp,eigvals_banded,"Python Library Documentation: function eigvals_banded in module scipy.linalg.decomp

eigvals_banded(a_band, lower=False, overwrite_a_band=False, select='a', select_range=None, check_finite=True)
    Solve real symmetric or complex hermitian band matrix eigenvalue problem.
    
    Find eigenvalues w of a::
    
        a v[:,i] = w[i] v[:,i]
        v.H v    = identity
    
    The matrix a is stored in a_band either in lower diagonal or upper
    diagonal ordered form:
    
        a_band[u + i - j, j] == a[i,j]        (if upper form; i <= j)
        a_band[    i - j, j] == a[i,j]        (if lower form; i >= j)
    
    where u is the number of bands above the diagonal.
    
    Example of a_band (shape of a is (6,6), u=2)::
    
        upper form:
        *   *   a02 a13 a24 a35
        *   a01 a12 a23 a34 a45
        a00 a11 a22 a33 a44 a55
    
        lower form:
        a00 a11 a22 a33 a44 a55
        a10 a21 a32 a43 a54 *
        a20 a31 a42 a53 *   *
    
    Cells marked with * are not used.
    
    Parameters
    ----------
    a_band : (u+1, M) array_like
        The bands of the M by M matrix a.
    lower : bool, optional
        Is the matrix in the lower form. (Default is upper form)
    overwrite_a_band : bool, optional
        Discard data in a_band (may enhance performance)
    select : {'a', 'v', 'i'}, optional
        Which eigenvalues to calculate
    
        ======  ========================================
        select  calculated
        ======  ========================================
        'a'     All eigenvalues
        'v'     Eigenvalues in the interval (min, max]
        'i'     Eigenvalues with indices min <= i <= max
        ======  ========================================
    select_range : (min, max), optional
        Range of selected eigenvalues
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    w : (M,) ndarray
        The eigenvalues, in ascending order, each repeated according to its
        multiplicity.
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge.
    
    See Also
    --------
    eig_banded : eigenvalues and right eigenvectors for symmetric/Hermitian
        band matrices
    eigvalsh_tridiagonal : eigenvalues of symmetric/Hermitian tridiagonal
        matrices
    eigvals : eigenvalues of general arrays
    eigh : eigenvalues and right eigenvectors for symmetric/Hermitian arrays
    eig : eigenvalues and right eigenvectors for non-symmetric arrays
    
    Examples
    --------
    >>> from scipy.linalg import eigvals_banded
    >>> A = np.array([[1, 5, 2, 0], [5, 2, 5, 2], [2, 5, 3, 5], [0, 2, 5, 4]])
    >>> Ab = np.array([[1, 2, 3, 4], [5, 5, 5, 0], [2, 2, 0, 0]])
    >>> w = eigvals_banded(Ab, lower=True)
    >>> w
    array([-4.26200532, -2.22987175,  3.95222349, 12.53965359])
",function,"('a_band', 'lower', 'overwrite_a_band', 'select', 'select_range', 'check_finite')","(nan, False, False, 'a', None, True)","(nan, 'bool', 'bool', 'str', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a_band, lower=False, overwrite_a_band=False, select='a', select_range=None, check_finite=True)"",)"
scipy,1.1.0,scipy.linalg.decomp.eigvalsh,linalg.decomp,eigvalsh,"Python Library Documentation: function eigvalsh in module scipy.linalg.decomp

eigvalsh(a, b=None, lower=True, overwrite_a=False, overwrite_b=False, turbo=True, eigvals=None, type=1, check_finite=True)
    Solve an ordinary or generalized eigenvalue problem for a complex
    Hermitian or real symmetric matrix.
    
    Find eigenvalues w of matrix a, where b is positive definite::
    
                      a v[:,i] = w[i] b v[:,i]
        v[i,:].conj() a v[:,i] = w[i]
        v[i,:].conj() b v[:,i] = 1
    
    
    Parameters
    ----------
    a : (M, M) array_like
        A complex Hermitian or real symmetric matrix whose eigenvalues and
        eigenvectors will be computed.
    b : (M, M) array_like, optional
        A complex Hermitian or real symmetric definite positive matrix in.
        If omitted, identity matrix is assumed.
    lower : bool, optional
        Whether the pertinent array data is taken from the lower or upper
        triangle of `a`. (Default: lower)
    turbo : bool, optional
        Use divide and conquer algorithm (faster but expensive in memory,
        only for generalized eigenvalue problem and if eigvals=None)
    eigvals : tuple (lo, hi), optional
        Indexes of the smallest and largest (in ascending order) eigenvalues
        and corresponding eigenvectors to be returned: 0 <= lo < hi <= M-1.
        If omitted, all eigenvalues and eigenvectors are returned.
    type : int, optional
        Specifies the problem type to be solved:
    
           type = 1: a   v[:,i] = w[i] b v[:,i]
    
           type = 2: a b v[:,i] = w[i]   v[:,i]
    
           type = 3: b a v[:,i] = w[i]   v[:,i]
    overwrite_a : bool, optional
        Whether to overwrite data in `a` (may improve performance)
    overwrite_b : bool, optional
        Whether to overwrite data in `b` (may improve performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    w : (N,) float ndarray
        The N (1<=N<=M) selected eigenvalues, in ascending order, each
        repeated according to its multiplicity.
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge,
        an error occurred, or b matrix is not definite positive. Note that
        if input matrices are not symmetric or hermitian, no error is reported
        but results will be wrong.
    
    See Also
    --------
    eigh : eigenvalues and right eigenvectors for symmetric/Hermitian arrays
    eigvals : eigenvalues of general arrays
    eigvals_banded : eigenvalues for symmetric/Hermitian band matrices
    eigvalsh_tridiagonal : eigenvalues of symmetric/Hermitian tridiagonal
        matrices
    
    Notes
    -----
    This function does not check the input array for being hermitian/symmetric
    in order to allow for representing arrays with only their upper/lower
    triangular parts.
    
    Examples
    --------
    >>> from scipy.linalg import eigvalsh
    >>> A = np.array([[6, 3, 1, 5], [3, 0, 5, 1], [1, 5, 6, 2], [5, 1, 2, 2]])
    >>> w = eigvalsh(A)
    >>> w
    array([-3.74637491, -0.76263923,  6.08502336, 12.42399079])
",function,"('(a, b=None, lower=True, overwrite_a=False, overwrite_b=False, turbo=True, eigvals=None, type=1, check_finite=True)',)",scipy,1.1.0,scipy.linalg.decomp.eigvalsh,linalg.decomp,eigvalsh,"Python Library Documentation: function eigvalsh in module scipy.linalg.decomp

eigvalsh(a, b=None, lower=True, overwrite_a=False, overwrite_b=False, turbo=True, eigvals=None, type=1, check_finite=True)
    Solve an ordinary or generalized eigenvalue problem for a complex
    Hermitian or real symmetric matrix.
    
    Find eigenvalues w of matrix a, where b is positive definite::
    
                      a v[:,i] = w[i] b v[:,i]
        v[i,:].conj() a v[:,i] = w[i]
        v[i,:].conj() b v[:,i] = 1
    
    
    Parameters
    ----------
    a : (M, M) array_like
        A complex Hermitian or real symmetric matrix whose eigenvalues and
        eigenvectors will be computed.
    b : (M, M) array_like, optional
        A complex Hermitian or real symmetric definite positive matrix in.
        If omitted, identity matrix is assumed.
    lower : bool, optional
        Whether the pertinent array data is taken from the lower or upper
        triangle of `a`. (Default: lower)
    turbo : bool, optional
        Use divide and conquer algorithm (faster but expensive in memory,
        only for generalized eigenvalue problem and if eigvals=None)
    eigvals : tuple (lo, hi), optional
        Indexes of the smallest and largest (in ascending order) eigenvalues
        and corresponding eigenvectors to be returned: 0 <= lo < hi <= M-1.
        If omitted, all eigenvalues and eigenvectors are returned.
    type : int, optional
        Specifies the problem type to be solved:
    
           type = 1: a   v[:,i] = w[i] b v[:,i]
    
           type = 2: a b v[:,i] = w[i]   v[:,i]
    
           type = 3: b a v[:,i] = w[i]   v[:,i]
    overwrite_a : bool, optional
        Whether to overwrite data in `a` (may improve performance)
    overwrite_b : bool, optional
        Whether to overwrite data in `b` (may improve performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    w : (N,) float ndarray
        The N (1<=N<=M) selected eigenvalues, in ascending order, each
        repeated according to its multiplicity.
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge,
        an error occurred, or b matrix is not definite positive. Note that
        if input matrices are not symmetric or hermitian, no error is reported
        but results will be wrong.
    
    See Also
    --------
    eigh : eigenvalues and right eigenvectors for symmetric/Hermitian arrays
    eigvals : eigenvalues of general arrays
    eigvals_banded : eigenvalues for symmetric/Hermitian band matrices
    eigvalsh_tridiagonal : eigenvalues of symmetric/Hermitian tridiagonal
        matrices
    
    Notes
    -----
    This function does not check the input array for being hermitian/symmetric
    in order to allow for representing arrays with only their upper/lower
    triangular parts.
    
    Examples
    --------
    >>> from scipy.linalg import eigvalsh
    >>> A = np.array([[6, 3, 1, 5], [3, 0, 5, 1], [1, 5, 6, 2], [5, 1, 2, 2]])
    >>> w = eigvalsh(A)
    >>> w
    array([-3.74637491, -0.76263923,  6.08502336, 12.42399079])
",function,"('a', 'b', 'lower', 'overwrite_a', 'overwrite_b', 'turbo', 'eigvals', 'type', 'check_finite')","(nan, None, True, False, False, True, None, 1, True)","(nan, 'NoneType', 'bool', 'bool', 'bool', 'bool', 'NoneType', 'int', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, b=None, lower=True, overwrite_a=False, overwrite_b=False, turbo=True, eigvals=None, type=1, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.decomp.eigvalsh_tridiagonal,linalg.decomp,eigvalsh_tridiagonal,"Python Library Documentation: function eigvalsh_tridiagonal in module scipy.linalg.decomp

eigvalsh_tridiagonal(d, e, select='a', select_range=None, check_finite=True, tol=0.0, lapack_driver='auto')
    Solve eigenvalue problem for a real symmetric tridiagonal matrix.
    
    Find eigenvalues `w` of ``a``::
    
        a v[:,i] = w[i] v[:,i]
        v.H v    = identity
    
    For a real symmetric matrix ``a`` with diagonal elements `d` and
    off-diagonal elements `e`.
    
    Parameters
    ----------
    d : ndarray, shape (ndim,)
        The diagonal elements of the array.
    e : ndarray, shape (ndim-1,)
        The off-diagonal elements of the array.
    select : {'a', 'v', 'i'}, optional
        Which eigenvalues to calculate
    
        ======  ========================================
        select  calculated
        ======  ========================================
        'a'     All eigenvalues
        'v'     Eigenvalues in the interval (min, max]
        'i'     Eigenvalues with indices min <= i <= max
        ======  ========================================
    select_range : (min, max), optional
        Range of selected eigenvalues
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    tol : float
        The absolute tolerance to which each eigenvalue is required
        (only used when ``lapack_driver='stebz'``).
        An eigenvalue (or cluster) is considered to have converged if it
        lies in an interval of this width. If <= 0. (default),
        the value ``eps*|a|`` is used where eps is the machine precision,
        and ``|a|`` is the 1-norm of the matrix ``a``.
    lapack_driver : str
        LAPACK function to use, can be 'auto', 'stemr', 'stebz',  'sterf',
        or 'stev'. When 'auto' (default), it will use 'stemr' if ``select='a'``
        and 'stebz' otherwise. 'sterf' and 'stev' can only be used when
        ``select='a'``.
    
    Returns
    -------
    w : (M,) ndarray
        The eigenvalues, in ascending order, each repeated according to its
        multiplicity.
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge.
    
    See Also
    --------
    eigh_tridiagonal : eigenvalues and right eiegenvectors for
        symmetric/Hermitian tridiagonal matrices
    
    Examples
    --------
    >>> from scipy.linalg import eigvalsh_tridiagonal, eigvalsh
    >>> d = 3*np.ones(4)
    >>> e = -1*np.ones(3)
    >>> w = eigvalsh_tridiagonal(d, e)
    >>> A = np.diag(d) + np.diag(e, k=1) + np.diag(e, k=-1)
    >>> w2 = eigvalsh(A)  # Verify with other eigenvalue routines
    >>> np.allclose(w - w2, np.zeros(4))
    True
",function,"(""(d, e, select='a', select_range=None, check_finite=True, tol=0.0, lapack_driver='auto')"",)",scipy,1.1.0,scipy.linalg.decomp.eigvalsh_tridiagonal,linalg.decomp,eigvalsh_tridiagonal,"Python Library Documentation: function eigvalsh_tridiagonal in module scipy.linalg.decomp

eigvalsh_tridiagonal(d, e, select='a', select_range=None, check_finite=True, tol=0.0, lapack_driver='auto')
    Solve eigenvalue problem for a real symmetric tridiagonal matrix.
    
    Find eigenvalues `w` of ``a``::
    
        a v[:,i] = w[i] v[:,i]
        v.H v    = identity
    
    For a real symmetric matrix ``a`` with diagonal elements `d` and
    off-diagonal elements `e`.
    
    Parameters
    ----------
    d : ndarray, shape (ndim,)
        The diagonal elements of the array.
    e : ndarray, shape (ndim-1,)
        The off-diagonal elements of the array.
    select : {'a', 'v', 'i'}, optional
        Which eigenvalues to calculate
    
        ======  ========================================
        select  calculated
        ======  ========================================
        'a'     All eigenvalues
        'v'     Eigenvalues in the interval (min, max]
        'i'     Eigenvalues with indices min <= i <= max
        ======  ========================================
    select_range : (min, max), optional
        Range of selected eigenvalues
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    tol : float
        The absolute tolerance to which each eigenvalue is required
        (only used when ``lapack_driver='stebz'``).
        An eigenvalue (or cluster) is considered to have converged if it
        lies in an interval of this width. If <= 0. (default),
        the value ``eps*|a|`` is used where eps is the machine precision,
        and ``|a|`` is the 1-norm of the matrix ``a``.
    lapack_driver : str
        LAPACK function to use, can be 'auto', 'stemr', 'stebz',  'sterf',
        or 'stev'. When 'auto' (default), it will use 'stemr' if ``select='a'``
        and 'stebz' otherwise. 'sterf' and 'stev' can only be used when
        ``select='a'``.
    
    Returns
    -------
    w : (M,) ndarray
        The eigenvalues, in ascending order, each repeated according to its
        multiplicity.
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge.
    
    See Also
    --------
    eigh_tridiagonal : eigenvalues and right eiegenvectors for
        symmetric/Hermitian tridiagonal matrices
    
    Examples
    --------
    >>> from scipy.linalg import eigvalsh_tridiagonal, eigvalsh
    >>> d = 3*np.ones(4)
    >>> e = -1*np.ones(3)
    >>> w = eigvalsh_tridiagonal(d, e)
    >>> A = np.diag(d) + np.diag(e, k=1) + np.diag(e, k=-1)
    >>> w2 = eigvalsh(A)  # Verify with other eigenvalue routines
    >>> np.allclose(w - w2, np.zeros(4))
    True
",function,"('d', 'e', 'select', 'select_range', 'check_finite', 'tol', 'lapack_driver')","(nan, nan, 'a', None, True, 0.0, 'auto')","(nan, nan, 'str', 'NoneType', 'bool', 'float', 'str')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(d, e, select='a', select_range=None, check_finite=True, tol=0.0, lapack_driver='auto')"",)"
scipy,1.1.0,scipy.linalg.decomp.einsum,linalg.decomp,einsum,"Python Library Documentation: function einsum in module numpy.core.einsumfunc

einsum(*operands, **kwargs)
    einsum(subscripts, *operands, out=None, dtype=None, order='K',
           casting='safe', optimize=False)
    
    Evaluates the Einstein summation convention on the operands.
    
    Using the Einstein summation convention, many common multi-dimensional
    array operations can be represented in a simple fashion.  This function
    provides a way to compute such summations. The best way to understand this
    function is to try the examples below, which show how many common NumPy
    functions can be implemented as calls to `einsum`.
    
    Parameters
    ----------
    subscripts : str
        Specifies the subscripts for summation.
    operands : list of array_like
        These are the arrays for the operation.
    out : {ndarray, None}, optional
        If provided, the calculation is done into this array.
    dtype : {data-type, None}, optional
        If provided, forces the calculation to use the data type specified.
        Note that you may have to also give a more liberal `casting`
        parameter to allow the conversions. Default is None.
    order : {'C', 'F', 'A', 'K'}, optional
        Controls the memory layout of the output. 'C' means it should
        be C contiguous. 'F' means it should be Fortran contiguous,
        'A' means it should be 'F' if the inputs are all 'F', 'C' otherwise.
        'K' means it should be as close to the layout as the inputs as
        is possible, including arbitrarily permuted axes.
        Default is 'K'.
    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
        Controls what kind of data casting may occur.  Setting this to
        'unsafe' is not recommended, as it can adversely affect accumulations.
    
          * 'no' means the data types should not be cast at all.
          * 'equiv' means only byte-order changes are allowed.
          * 'safe' means only casts which can preserve values are allowed.
          * 'same_kind' means only safe casts or casts within a kind,
            like float64 to float32, are allowed.
          * 'unsafe' means any data conversions may be done.
    
        Default is 'safe'.
    optimize : {False, True, 'greedy', 'optimal'}, optional
        Controls if intermediate optimization should occur. No optimization
        will occur if False and True will default to the 'greedy' algorithm.
        Also accepts an explicit contraction list from the ``np.einsum_path``
        function. See ``np.einsum_path`` for more details. Default is False.
    
    Returns
    -------
    output : ndarray
        The calculation based on the Einstein summation convention.
    
    See Also
    --------
    einsum_path, dot, inner, outer, tensordot, linalg.multi_dot
    
    Notes
    -----
    .. versionadded:: 1.6.0
    
    The subscripts string is a comma-separated list of subscript labels,
    where each label refers to a dimension of the corresponding operand.
    Repeated subscripts labels in one operand take the diagonal.  For example,
    ``np.einsum('ii', a)`` is equivalent to ``np.trace(a)``.
    
    Whenever a label is repeated, it is summed, so ``np.einsum('i,i', a, b)``
    is equivalent to ``np.inner(a,b)``.  If a label appears only once,
    it is not summed, so ``np.einsum('i', a)`` produces a view of ``a``
    with no changes.
    
    The order of labels in the output is by default alphabetical.  This
    means that ``np.einsum('ij', a)`` doesn't affect a 2D array, while
    ``np.einsum('ji', a)`` takes its transpose.
    
    The output can be controlled by specifying output subscript labels
    as well.  This specifies the label order, and allows summing to
    be disallowed or forced when desired.  The call ``np.einsum('i->', a)``
    is like ``np.sum(a, axis=-1)``, and ``np.einsum('ii->i', a)``
    is like ``np.diag(a)``.  The difference is that `einsum` does not
    allow broadcasting by default.
    
    To enable and control broadcasting, use an ellipsis.  Default
    NumPy-style broadcasting is done by adding an ellipsis
    to the left of each term, like ``np.einsum('...ii->...i', a)``.
    To take the trace along the first and last axes,
    you can do ``np.einsum('i...i', a)``, or to do a matrix-matrix
    product with the left-most indices instead of rightmost, you can do
    ``np.einsum('ij...,jk...->ik...', a, b)``.
    
    When there is only one operand, no axes are summed, and no output
    parameter is provided, a view into the operand is returned instead
    of a new array.  Thus, taking the diagonal as ``np.einsum('ii->i', a)``
    produces a view.
    
    An alternative way to provide the subscripts and operands is as
    ``einsum(op0, sublist0, op1, sublist1, ..., [sublistout])``. The examples
    below have corresponding `einsum` calls with the two parameter methods.
    
    .. versionadded:: 1.10.0
    
    Views returned from einsum are now writeable whenever the input array
    is writeable. For example, ``np.einsum('ijk...->kji...', a)`` will now
    have the same effect as ``np.swapaxes(a, 0, 2)`` and
    ``np.einsum('ii->i', a)`` will return a writeable view of the diagonal
    of a 2D array.
    
    .. versionadded:: 1.12.0
    
    Added the ``optimize`` argument which will optimize the contraction order
    of an einsum expression. For a contraction with three or more operands this
    can greatly increase the computational efficiency at the cost of a larger
    memory footprint during computation.
    
    See ``np.einsum_path`` for more details.
    
    Examples
    --------
    >>> a = np.arange(25).reshape(5,5)
    >>> b = np.arange(5)
    >>> c = np.arange(6).reshape(2,3)
    
    >>> np.einsum('ii', a)
    60
    >>> np.einsum(a, [0,0])
    60
    >>> np.trace(a)
    60
    
    >>> np.einsum('ii->i', a)
    array([ 0,  6, 12, 18, 24])
    >>> np.einsum(a, [0,0], [0])
    array([ 0,  6, 12, 18, 24])
    >>> np.diag(a)
    array([ 0,  6, 12, 18, 24])
    
    >>> np.einsum('ij,j', a, b)
    array([ 30,  80, 130, 180, 230])
    >>> np.einsum(a, [0,1], b, [1])
    array([ 30,  80, 130, 180, 230])
    >>> np.dot(a, b)
    array([ 30,  80, 130, 180, 230])
    >>> np.einsum('...j,j', a, b)
    array([ 30,  80, 130, 180, 230])
    
    >>> np.einsum('ji', c)
    array([[0, 3],
           [1, 4],
           [2, 5]])
    >>> np.einsum(c, [1,0])
    array([[0, 3],
           [1, 4],
           [2, 5]])
    >>> c.T
    array([[0, 3],
           [1, 4],
           [2, 5]])
    
    >>> np.einsum('..., ...', 3, c)
    array([[ 0,  3,  6],
           [ 9, 12, 15]])
    >>> np.einsum(',ij', 3, C)
    array([[ 0,  3,  6],
           [ 9, 12, 15]])
    >>> np.einsum(3, [Ellipsis], c, [Ellipsis])
    array([[ 0,  3,  6],
           [ 9, 12, 15]])
    >>> np.multiply(3, c)
    array([[ 0,  3,  6],
           [ 9, 12, 15]])
    
    >>> np.einsum('i,i', b, b)
    30
    >>> np.einsum(b, [0], b, [0])
    30
    >>> np.inner(b,b)
    30
    
    >>> np.einsum('i,j', np.arange(2)+1, b)
    array([[0, 1, 2, 3, 4],
           [0, 2, 4, 6, 8]])
    >>> np.einsum(np.arange(2)+1, [0], b, [1])
    array([[0, 1, 2, 3, 4],
           [0, 2, 4, 6, 8]])
    >>> np.outer(np.arange(2)+1, b)
    array([[0, 1, 2, 3, 4],
           [0, 2, 4, 6, 8]])
    
    >>> np.einsum('i...->...', a)
    array([50, 55, 60, 65, 70])
    >>> np.einsum(a, [0,Ellipsis], [Ellipsis])
    array([50, 55, 60, 65, 70])
    >>> np.sum(a, axis=0)
    array([50, 55, 60, 65, 70])
    
    >>> a = np.arange(60.).reshape(3,4,5)
    >>> b = np.arange(24.).reshape(4,3,2)
    >>> np.einsum('ijk,jil->kl', a, b)
    array([[ 4400.,  4730.],
           [ 4532.,  4874.],
           [ 4664.,  5018.],
           [ 4796.,  5162.],
           [ 4928.,  5306.]])
    >>> np.einsum(a, [0,1,2], b, [1,0,3], [2,3])
    array([[ 4400.,  4730.],
           [ 4532.,  4874.],
           [ 4664.,  5018.],
           [ 4796.,  5162.],
           [ 4928.,  5306.]])
    >>> np.tensordot(a,b, axes=([1,0],[0,1]))
    array([[ 4400.,  4730.],
           [ 4532.,  4874.],
           [ 4664.,  5018.],
           [ 4796.,  5162.],
           [ 4928.,  5306.]])
    
    >>> a = np.arange(6).reshape((3,2))
    >>> b = np.arange(12).reshape((4,3))
    >>> np.einsum('ki,jk->ij', a, b)
    array([[10, 28, 46, 64],
           [13, 40, 67, 94]])
    >>> np.einsum('ki,...k->i...', a, b)
    array([[10, 28, 46, 64],
           [13, 40, 67, 94]])
    >>> np.einsum('k...,jk', a, b)
    array([[10, 28, 46, 64],
           [13, 40, 67, 94]])
    
    >>> # since version 1.10.0
    >>> a = np.zeros((3, 3))
    >>> np.einsum('ii->i', a)[:] = 1
    >>> a
    array([[ 1.,  0.,  0.],
           [ 0.,  1.,  0.],
           [ 0.,  0.,  1.]])
",function,"('(*operands, **kwargs)',)",scipy,1.1.0,scipy.linalg.decomp.einsum,linalg.decomp,einsum,"Python Library Documentation: function einsum in module numpy.core.einsumfunc

einsum(*operands, **kwargs)
    einsum(subscripts, *operands, out=None, dtype=None, order='K',
           casting='safe', optimize=False)
    
    Evaluates the Einstein summation convention on the operands.
    
    Using the Einstein summation convention, many common multi-dimensional
    array operations can be represented in a simple fashion.  This function
    provides a way to compute such summations. The best way to understand this
    function is to try the examples below, which show how many common NumPy
    functions can be implemented as calls to `einsum`.
    
    Parameters
    ----------
    subscripts : str
        Specifies the subscripts for summation.
    operands : list of array_like
        These are the arrays for the operation.
    out : {ndarray, None}, optional
        If provided, the calculation is done into this array.
    dtype : {data-type, None}, optional
        If provided, forces the calculation to use the data type specified.
        Note that you may have to also give a more liberal `casting`
        parameter to allow the conversions. Default is None.
    order : {'C', 'F', 'A', 'K'}, optional
        Controls the memory layout of the output. 'C' means it should
        be C contiguous. 'F' means it should be Fortran contiguous,
        'A' means it should be 'F' if the inputs are all 'F', 'C' otherwise.
        'K' means it should be as close to the layout as the inputs as
        is possible, including arbitrarily permuted axes.
        Default is 'K'.
    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
        Controls what kind of data casting may occur.  Setting this to
        'unsafe' is not recommended, as it can adversely affect accumulations.
    
          * 'no' means the data types should not be cast at all.
          * 'equiv' means only byte-order changes are allowed.
          * 'safe' means only casts which can preserve values are allowed.
          * 'same_kind' means only safe casts or casts within a kind,
            like float64 to float32, are allowed.
          * 'unsafe' means any data conversions may be done.
    
        Default is 'safe'.
    optimize : {False, True, 'greedy', 'optimal'}, optional
        Controls if intermediate optimization should occur. No optimization
        will occur if False and True will default to the 'greedy' algorithm.
        Also accepts an explicit contraction list from the ``np.einsum_path``
        function. See ``np.einsum_path`` for more details. Default is False.
    
    Returns
    -------
    output : ndarray
        The calculation based on the Einstein summation convention.
    
    See Also
    --------
    einsum_path, dot, inner, outer, tensordot, linalg.multi_dot
    
    Notes
    -----
    .. versionadded:: 1.6.0
    
    The subscripts string is a comma-separated list of subscript labels,
    where each label refers to a dimension of the corresponding operand.
    Repeated subscripts labels in one operand take the diagonal.  For example,
    ``np.einsum('ii', a)`` is equivalent to ``np.trace(a)``.
    
    Whenever a label is repeated, it is summed, so ``np.einsum('i,i', a, b)``
    is equivalent to ``np.inner(a,b)``.  If a label appears only once,
    it is not summed, so ``np.einsum('i', a)`` produces a view of ``a``
    with no changes.
    
    The order of labels in the output is by default alphabetical.  This
    means that ``np.einsum('ij', a)`` doesn't affect a 2D array, while
    ``np.einsum('ji', a)`` takes its transpose.
    
    The output can be controlled by specifying output subscript labels
    as well.  This specifies the label order, and allows summing to
    be disallowed or forced when desired.  The call ``np.einsum('i->', a)``
    is like ``np.sum(a, axis=-1)``, and ``np.einsum('ii->i', a)``
    is like ``np.diag(a)``.  The difference is that `einsum` does not
    allow broadcasting by default.
    
    To enable and control broadcasting, use an ellipsis.  Default
    NumPy-style broadcasting is done by adding an ellipsis
    to the left of each term, like ``np.einsum('...ii->...i', a)``.
    To take the trace along the first and last axes,
    you can do ``np.einsum('i...i', a)``, or to do a matrix-matrix
    product with the left-most indices instead of rightmost, you can do
    ``np.einsum('ij...,jk...->ik...', a, b)``.
    
    When there is only one operand, no axes are summed, and no output
    parameter is provided, a view into the operand is returned instead
    of a new array.  Thus, taking the diagonal as ``np.einsum('ii->i', a)``
    produces a view.
    
    An alternative way to provide the subscripts and operands is as
    ``einsum(op0, sublist0, op1, sublist1, ..., [sublistout])``. The examples
    below have corresponding `einsum` calls with the two parameter methods.
    
    .. versionadded:: 1.10.0
    
    Views returned from einsum are now writeable whenever the input array
    is writeable. For example, ``np.einsum('ijk...->kji...', a)`` will now
    have the same effect as ``np.swapaxes(a, 0, 2)`` and
    ``np.einsum('ii->i', a)`` will return a writeable view of the diagonal
    of a 2D array.
    
    .. versionadded:: 1.12.0
    
    Added the ``optimize`` argument which will optimize the contraction order
    of an einsum expression. For a contraction with three or more operands this
    can greatly increase the computational efficiency at the cost of a larger
    memory footprint during computation.
    
    See ``np.einsum_path`` for more details.
    
    Examples
    --------
    >>> a = np.arange(25).reshape(5,5)
    >>> b = np.arange(5)
    >>> c = np.arange(6).reshape(2,3)
    
    >>> np.einsum('ii', a)
    60
    >>> np.einsum(a, [0,0])
    60
    >>> np.trace(a)
    60
    
    >>> np.einsum('ii->i', a)
    array([ 0,  6, 12, 18, 24])
    >>> np.einsum(a, [0,0], [0])
    array([ 0,  6, 12, 18, 24])
    >>> np.diag(a)
    array([ 0,  6, 12, 18, 24])
    
    >>> np.einsum('ij,j', a, b)
    array([ 30,  80, 130, 180, 230])
    >>> np.einsum(a, [0,1], b, [1])
    array([ 30,  80, 130, 180, 230])
    >>> np.dot(a, b)
    array([ 30,  80, 130, 180, 230])
    >>> np.einsum('...j,j', a, b)
    array([ 30,  80, 130, 180, 230])
    
    >>> np.einsum('ji', c)
    array([[0, 3],
           [1, 4],
           [2, 5]])
    >>> np.einsum(c, [1,0])
    array([[0, 3],
           [1, 4],
           [2, 5]])
    >>> c.T
    array([[0, 3],
           [1, 4],
           [2, 5]])
    
    >>> np.einsum('..., ...', 3, c)
    array([[ 0,  3,  6],
           [ 9, 12, 15]])
    >>> np.einsum(',ij', 3, C)
    array([[ 0,  3,  6],
           [ 9, 12, 15]])
    >>> np.einsum(3, [Ellipsis], c, [Ellipsis])
    array([[ 0,  3,  6],
           [ 9, 12, 15]])
    >>> np.multiply(3, c)
    array([[ 0,  3,  6],
           [ 9, 12, 15]])
    
    >>> np.einsum('i,i', b, b)
    30
    >>> np.einsum(b, [0], b, [0])
    30
    >>> np.inner(b,b)
    30
    
    >>> np.einsum('i,j', np.arange(2)+1, b)
    array([[0, 1, 2, 3, 4],
           [0, 2, 4, 6, 8]])
    >>> np.einsum(np.arange(2)+1, [0], b, [1])
    array([[0, 1, 2, 3, 4],
           [0, 2, 4, 6, 8]])
    >>> np.outer(np.arange(2)+1, b)
    array([[0, 1, 2, 3, 4],
           [0, 2, 4, 6, 8]])
    
    >>> np.einsum('i...->...', a)
    array([50, 55, 60, 65, 70])
    >>> np.einsum(a, [0,Ellipsis], [Ellipsis])
    array([50, 55, 60, 65, 70])
    >>> np.sum(a, axis=0)
    array([50, 55, 60, 65, 70])
    
    >>> a = np.arange(60.).reshape(3,4,5)
    >>> b = np.arange(24.).reshape(4,3,2)
    >>> np.einsum('ijk,jil->kl', a, b)
    array([[ 4400.,  4730.],
           [ 4532.,  4874.],
           [ 4664.,  5018.],
           [ 4796.,  5162.],
           [ 4928.,  5306.]])
    >>> np.einsum(a, [0,1,2], b, [1,0,3], [2,3])
    array([[ 4400.,  4730.],
           [ 4532.,  4874.],
           [ 4664.,  5018.],
           [ 4796.,  5162.],
           [ 4928.,  5306.]])
    >>> np.tensordot(a,b, axes=([1,0],[0,1]))
    array([[ 4400.,  4730.],
           [ 4532.,  4874.],
           [ 4664.,  5018.],
           [ 4796.,  5162.],
           [ 4928.,  5306.]])
    
    >>> a = np.arange(6).reshape((3,2))
    >>> b = np.arange(12).reshape((4,3))
    >>> np.einsum('ki,jk->ij', a, b)
    array([[10, 28, 46, 64],
           [13, 40, 67, 94]])
    >>> np.einsum('ki,...k->i...', a, b)
    array([[10, 28, 46, 64],
           [13, 40, 67, 94]])
    >>> np.einsum('k...,jk', a, b)
    array([[10, 28, 46, 64],
           [13, 40, 67, 94]])
    
    >>> # since version 1.10.0
    >>> a = np.zeros((3, 3))
    >>> np.einsum('ii->i', a)[:] = 1
    >>> a
    array([[ 1.,  0.,  0.],
           [ 0.,  1.,  0.],
           [ 0.,  0.,  1.]])
",function,(),(),(),(),"('(*operands, **kwargs)',)"
scipy,1.1.0,scipy.linalg.decomp.eye,linalg.decomp,eye,"Python Library Documentation: function eye in module numpy.lib.twodim_base

eye(N, M=None, k=0, dtype=<class 'float'>, order='C')
    Return a 2-D array with ones on the diagonal and zeros elsewhere.
    
    Parameters
    ----------
    N : int
      Number of rows in the output.
    M : int, optional
      Number of columns in the output. If None, defaults to `N`.
    k : int, optional
      Index of the diagonal: 0 (the default) refers to the main diagonal,
      a positive value refers to an upper diagonal, and a negative value
      to a lower diagonal.
    dtype : data-type, optional
      Data-type of the returned array.
    order : {'C', 'F'}, optional
        Whether the output should be stored in row-major (C-style) or
        column-major (Fortran-style) order in memory.
    
        .. versionadded:: 1.14.0
    
    Returns
    -------
    I : ndarray of shape (N,M)
      An array where all elements are equal to zero, except for the `k`-th
      diagonal, whose values are equal to one.
    
    See Also
    --------
    identity : (almost) equivalent function
    diag : diagonal 2-D array from a 1-D array specified by the user.
    
    Examples
    --------
    >>> np.eye(2, dtype=int)
    array([[1, 0],
           [0, 1]])
    >>> np.eye(3, k=1)
    array([[ 0.,  1.,  0.],
           [ 0.,  0.,  1.],
           [ 0.,  0.,  0.]])
",function,"(""(N, M=None, k=0, dtype=<class 'float'>, order='C')"",)",scipy,1.1.0,scipy.linalg.decomp.eye,linalg.decomp,eye,"Python Library Documentation: function eye in module numpy.lib.twodim_base

eye(N, M=None, k=0, dtype=<class 'float'>, order='C')
    Return a 2-D array with ones on the diagonal and zeros elsewhere.
    
    Parameters
    ----------
    N : int
      Number of rows in the output.
    M : int, optional
      Number of columns in the output. If None, defaults to `N`.
    k : int, optional
      Index of the diagonal: 0 (the default) refers to the main diagonal,
      a positive value refers to an upper diagonal, and a negative value
      to a lower diagonal.
    dtype : data-type, optional
      Data-type of the returned array.
    order : {'C', 'F'}, optional
        Whether the output should be stored in row-major (C-style) or
        column-major (Fortran-style) order in memory.
    
        .. versionadded:: 1.14.0
    
    Returns
    -------
    I : ndarray of shape (N,M)
      An array where all elements are equal to zero, except for the `k`-th
      diagonal, whose values are equal to one.
    
    See Also
    --------
    identity : (almost) equivalent function
    diag : diagonal 2-D array from a 1-D array specified by the user.
    
    Examples
    --------
    >>> np.eye(2, dtype=int)
    array([[1, 0],
           [0, 1]])
    >>> np.eye(3, k=1)
    array([[ 0.,  1.,  0.],
           [ 0.,  0.,  1.],
           [ 0.,  0.,  0.]])
",function,"('N', 'M', 'k', 'dtype', 'order')","(nan, None, 0, <class 'float'>, 'C')","(nan, 'NoneType', 'int', 'type', 'str')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(N, M=None, k=0, dtype=<class 'float'>, order='C')"",)"
scipy,1.1.0,scipy.linalg.decomp.flatnonzero,linalg.decomp,flatnonzero,"Python Library Documentation: function flatnonzero in module numpy.core.numeric

flatnonzero(a)
    Return indices that are non-zero in the flattened version of a.
    
    This is equivalent to a.ravel().nonzero()[0].
    
    Parameters
    ----------
    a : ndarray
        Input array.
    
    Returns
    -------
    res : ndarray
        Output array, containing the indices of the elements of `a.ravel()`
        that are non-zero.
    
    See Also
    --------
    nonzero : Return the indices of the non-zero elements of the input array.
    ravel : Return a 1-D array containing the elements of the input array.
    
    Examples
    --------
    >>> x = np.arange(-2, 3)
    >>> x
    array([-2, -1,  0,  1,  2])
    >>> np.flatnonzero(x)
    array([0, 1, 3, 4])
    
    Use the indices of the non-zero elements as an index array to extract
    these elements:
    
    >>> x.ravel()[np.flatnonzero(x)]
    array([-2, -1,  1,  2])
",function,"('(a)',)",scipy,1.1.0,scipy.linalg.decomp.flatnonzero,linalg.decomp,flatnonzero,"Python Library Documentation: function flatnonzero in module numpy.core.numeric

flatnonzero(a)
    Return indices that are non-zero in the flattened version of a.
    
    This is equivalent to a.ravel().nonzero()[0].
    
    Parameters
    ----------
    a : ndarray
        Input array.
    
    Returns
    -------
    res : ndarray
        Output array, containing the indices of the elements of `a.ravel()`
        that are non-zero.
    
    See Also
    --------
    nonzero : Return the indices of the non-zero elements of the input array.
    ravel : Return a 1-D array containing the elements of the input array.
    
    Examples
    --------
    >>> x = np.arange(-2, 3)
    >>> x
    array([-2, -1,  0,  1,  2])
    >>> np.flatnonzero(x)
    array([0, 1, 3, 4])
    
    Use the indices of the non-zero elements as an index array to extract
    these elements:
    
    >>> x.ravel()[np.flatnonzero(x)]
    array([-2, -1,  1,  2])
",function,"('a',)","(nan,)","(nan,)","('arg_info',)","('(a)',)"
scipy,1.1.0,scipy.linalg.decomp.get_lapack_funcs,linalg.decomp,get_lapack_funcs,"Python Library Documentation: function get_lapack_funcs in module scipy.linalg.lapack

get_lapack_funcs(names, arrays=(), dtype=None)
    Return available LAPACK function objects from names.
    
    Arrays are used to determine the optimal prefix of LAPACK routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of LAPACK functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of LAPACK
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In LAPACK, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively, and
    are stored in attribute ``typecode`` of the returned functions.
    
    Examples
    --------
    Suppose we would like to use '?lange' routine which computes the selected
    norm of an array. We pass our array in order to get the correct 'lange'
    flavor.
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_lange = LA.get_lapack_funcs('lange', (a,))
    >>> x_lange.typecode
    'd'
    >>> x_lange = LA.get_lapack_funcs('lange',(a*1j,))
    >>> x_lange.typecode
    'z'
    
    Several LAPACK routines work best when its internal WORK array has
    the optimal size (big enough for fast computation and small enough to
    avoid waste of memory). This size is determined also by a dedicated query
    to the function which is often wrapped as a standalone function and
    commonly denoted as ``###_lwork``. Below is an example for ``?sysv``
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(1000,1000)
    >>> b = np.random.rand(1000,1)*1j
    >>> # We pick up zsysv and zsysv_lwork due to b array
    ... xsysv, xlwork = LA.get_lapack_funcs(('sysv', 'sysv_lwork'), (a, b))
    >>> opt_lwork, _ = xlwork(a.shape[0])  # returns a complex for 'z' prefix
    >>> udut, ipiv, x, info = xsysv(a, b, lwork=int(opt_lwork.real))
",function,"('(names, arrays=(), dtype=None)',)",scipy,1.1.0,scipy.linalg.decomp.get_lapack_funcs,linalg.decomp,get_lapack_funcs,"Python Library Documentation: function get_lapack_funcs in module scipy.linalg.lapack

get_lapack_funcs(names, arrays=(), dtype=None)
    Return available LAPACK function objects from names.
    
    Arrays are used to determine the optimal prefix of LAPACK routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of LAPACK functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of LAPACK
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In LAPACK, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively, and
    are stored in attribute ``typecode`` of the returned functions.
    
    Examples
    --------
    Suppose we would like to use '?lange' routine which computes the selected
    norm of an array. We pass our array in order to get the correct 'lange'
    flavor.
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_lange = LA.get_lapack_funcs('lange', (a,))
    >>> x_lange.typecode
    'd'
    >>> x_lange = LA.get_lapack_funcs('lange',(a*1j,))
    >>> x_lange.typecode
    'z'
    
    Several LAPACK routines work best when its internal WORK array has
    the optimal size (big enough for fast computation and small enough to
    avoid waste of memory). This size is determined also by a dedicated query
    to the function which is often wrapped as a standalone function and
    commonly denoted as ``###_lwork``. Below is an example for ``?sysv``
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(1000,1000)
    >>> b = np.random.rand(1000,1)*1j
    >>> # We pick up zsysv and zsysv_lwork due to b array
    ... xsysv, xlwork = LA.get_lapack_funcs(('sysv', 'sysv_lwork'), (a, b))
    >>> opt_lwork, _ = xlwork(a.shape[0])  # returns a complex for 'z' prefix
    >>> udut, ipiv, x, info = xsysv(a, b, lwork=int(opt_lwork.real))
",function,"('names', 'arrays', 'dtype')","(nan, (), None)","(nan, 'tuple', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(names, arrays=(), dtype=None)',)"
scipy,1.1.0,scipy.linalg.decomp.hessenberg,linalg.decomp,hessenberg,"Python Library Documentation: function hessenberg in module scipy.linalg.decomp

hessenberg(a, calc_q=False, overwrite_a=False, check_finite=True)
    Compute Hessenberg form of a matrix.
    
    The Hessenberg decomposition is::
    
        A = Q H Q^H
    
    where `Q` is unitary/orthogonal and `H` has only zero elements below
    the first sub-diagonal.
    
    Parameters
    ----------
    a : (M, M) array_like
        Matrix to bring into Hessenberg form.
    calc_q : bool, optional
        Whether to compute the transformation matrix.  Default is False.
    overwrite_a : bool, optional
        Whether to overwrite `a`; may improve performance.
        Default is False.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    H : (M, M) ndarray
        Hessenberg form of `a`.
    Q : (M, M) ndarray
        Unitary/orthogonal similarity transformation matrix ``A = Q H Q^H``.
        Only returned if ``calc_q=True``.
    
    Examples
    --------
    >>> from scipy.linalg import hessenberg
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> H, Q = hessenberg(A, calc_q=True)
    >>> H
    array([[  2.        , -11.65843866,   1.42005301,   0.25349066],
           [ -9.94987437,  14.53535354,  -5.31022304,   2.43081618],
           [  0.        ,  -1.83299243,   0.38969961,  -0.51527034],
           [  0.        ,   0.        ,  -3.83189513,   1.07494686]])
    >>> np.allclose(Q @ H @ Q.conj().T - A, np.zeros((4, 4)))
    True
",function,"('(a, calc_q=False, overwrite_a=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.decomp.hessenberg,linalg.decomp,hessenberg,"Python Library Documentation: function hessenberg in module scipy.linalg.decomp

hessenberg(a, calc_q=False, overwrite_a=False, check_finite=True)
    Compute Hessenberg form of a matrix.
    
    The Hessenberg decomposition is::
    
        A = Q H Q^H
    
    where `Q` is unitary/orthogonal and `H` has only zero elements below
    the first sub-diagonal.
    
    Parameters
    ----------
    a : (M, M) array_like
        Matrix to bring into Hessenberg form.
    calc_q : bool, optional
        Whether to compute the transformation matrix.  Default is False.
    overwrite_a : bool, optional
        Whether to overwrite `a`; may improve performance.
        Default is False.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    H : (M, M) ndarray
        Hessenberg form of `a`.
    Q : (M, M) ndarray
        Unitary/orthogonal similarity transformation matrix ``A = Q H Q^H``.
        Only returned if ``calc_q=True``.
    
    Examples
    --------
    >>> from scipy.linalg import hessenberg
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> H, Q = hessenberg(A, calc_q=True)
    >>> H
    array([[  2.        , -11.65843866,   1.42005301,   0.25349066],
           [ -9.94987437,  14.53535354,  -5.31022304,   2.43081618],
           [  0.        ,  -1.83299243,   0.38969961,  -0.51527034],
           [  0.        ,   0.        ,  -3.83189513,   1.07494686]])
    >>> np.allclose(Q @ H @ Q.conj().T - A, np.zeros((4, 4)))
    True
",function,"('a', 'calc_q', 'overwrite_a', 'check_finite')","(nan, False, False, True)","(nan, 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, calc_q=False, overwrite_a=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.decomp.inexact,linalg.decomp,inexact,"Python Library Documentation: class inexact in module numpy

class inexact(number)
 |  Base class for numpy scalar types.
 |  
 |  Class from which most (all?) numpy scalar types are derived.  For
 |  consistency, exposes the same API as `ndarray`, despite many
 |  consequent attributes being either ""get-only,"" or completely irrelevant.
 |  This is the class from which it is strongly suggested users should derive
 |  custom scalar types.
 |  
 |  Method resolution order:
 |      inexact
 |      number
 |      generic
 |      builtins.object
 |  
 |  Methods inherited from generic:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __array__(...)
 |      sc.__array__(|type) return 0-dim array
 |  
 |  __array_wrap__(...)
 |      sc.__array_wrap__(obj) return scalar from array
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __copy__(...)
 |  
 |  __deepcopy__(...)
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __format__(...)
 |      NumPy array scalar formatter
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __round__(...)
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __setstate__(...)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  all(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  any(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmax(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmin(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argsort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  astype(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  byteswap(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  choose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  clip(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  compress(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  conj(...)
 |  
 |  conjugate(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  copy(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumprod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumsum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  diagonal(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dump(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dumps(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  fill(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  flatten(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  getfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  item(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  itemset(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  max(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  mean(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  min(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  newbyteorder(...)
 |      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.
 |      
 |      The `new_order` code can be any from the following:
 |      
 |      * 'S' - swap dtype from current to opposite endian
 |      * {'<', 'L'} - little endian
 |      * {'>', 'B'} - big endian
 |      * {'=', 'N'} - native order
 |      * {'|', 'I'} - ignore (no change to byte order)
 |      
 |      Parameters
 |      ----------
 |      new_order : str, optional
 |          Byte order to force; a value from the byte order specifications
 |          above.  The default value ('S') results in swapping the current
 |          byte order. The code does a case-insensitive check on the first
 |          letter of `new_order` for the alternatives above.  For example,
 |          any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 |      
 |      
 |      Returns
 |      -------
 |      new_dtype : dtype
 |          New `dtype` object with the given change to the byte order.
 |  
 |  nonzero(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  prod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ptp(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  put(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ravel(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  repeat(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  reshape(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  resize(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  round(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  searchsorted(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setflags(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  squeeze(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  std(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  swapaxes(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  take(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tobytes(...)
 |  
 |  tofile(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tolist(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tostring(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  trace(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  transpose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  var(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  view(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from generic:
 |  
 |  T
 |      transpose
 |  
 |  __array_interface__
 |      Array protocol: Python side
 |  
 |  __array_priority__
 |      Array priority.
 |  
 |  __array_struct__
 |      Array protocol: struct
 |  
 |  base
 |      base object
 |  
 |  data
 |      pointer to start of data
 |  
 |  dtype
 |      get array data-descriptor
 |  
 |  flags
 |      integer value of flags
 |  
 |  flat
 |      a 1-d view of scalar
 |  
 |  imag
 |      imaginary part of scalar
 |  
 |  itemsize
 |      length of one element in bytes
 |  
 |  nbytes
 |      length of item in bytes
 |  
 |  ndim
 |      number of array dimensions
 |  
 |  real
 |      real part of scalar
 |  
 |  shape
 |      tuple of array dimensions
 |  
 |  size
 |      number of elements in the gentype
 |  
 |  strides
 |      tuple of bytes steps in each dimension
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from generic:
 |  
 |  __hash__ = None
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg.decomp.inexact,linalg.decomp,inexact,"Python Library Documentation: class inexact in module numpy

class inexact(number)
 |  Base class for numpy scalar types.
 |  
 |  Class from which most (all?) numpy scalar types are derived.  For
 |  consistency, exposes the same API as `ndarray`, despite many
 |  consequent attributes being either ""get-only,"" or completely irrelevant.
 |  This is the class from which it is strongly suggested users should derive
 |  custom scalar types.
 |  
 |  Method resolution order:
 |      inexact
 |      number
 |      generic
 |      builtins.object
 |  
 |  Methods inherited from generic:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __array__(...)
 |      sc.__array__(|type) return 0-dim array
 |  
 |  __array_wrap__(...)
 |      sc.__array_wrap__(obj) return scalar from array
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __copy__(...)
 |  
 |  __deepcopy__(...)
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __format__(...)
 |      NumPy array scalar formatter
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __round__(...)
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __setstate__(...)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  all(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  any(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmax(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmin(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argsort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  astype(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  byteswap(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  choose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  clip(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  compress(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  conj(...)
 |  
 |  conjugate(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  copy(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumprod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumsum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  diagonal(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dump(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dumps(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  fill(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  flatten(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  getfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  item(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  itemset(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  max(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  mean(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  min(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  newbyteorder(...)
 |      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.
 |      
 |      The `new_order` code can be any from the following:
 |      
 |      * 'S' - swap dtype from current to opposite endian
 |      * {'<', 'L'} - little endian
 |      * {'>', 'B'} - big endian
 |      * {'=', 'N'} - native order
 |      * {'|', 'I'} - ignore (no change to byte order)
 |      
 |      Parameters
 |      ----------
 |      new_order : str, optional
 |          Byte order to force; a value from the byte order specifications
 |          above.  The default value ('S') results in swapping the current
 |          byte order. The code does a case-insensitive check on the first
 |          letter of `new_order` for the alternatives above.  For example,
 |          any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 |      
 |      
 |      Returns
 |      -------
 |      new_dtype : dtype
 |          New `dtype` object with the given change to the byte order.
 |  
 |  nonzero(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  prod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ptp(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  put(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ravel(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  repeat(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  reshape(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  resize(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  round(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  searchsorted(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setflags(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  squeeze(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  std(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  swapaxes(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  take(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tobytes(...)
 |  
 |  tofile(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tolist(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tostring(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  trace(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  transpose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  var(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  view(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from generic:
 |  
 |  T
 |      transpose
 |  
 |  __array_interface__
 |      Array protocol: Python side
 |  
 |  __array_priority__
 |      Array priority.
 |  
 |  __array_struct__
 |      Array protocol: struct
 |  
 |  base
 |      base object
 |  
 |  data
 |      pointer to start of data
 |  
 |  dtype
 |      get array data-descriptor
 |  
 |  flags
 |      integer value of flags
 |  
 |  flat
 |      a 1-d view of scalar
 |  
 |  imag
 |      imaginary part of scalar
 |  
 |  itemsize
 |      length of one element in bytes
 |  
 |  nbytes
 |      length of item in bytes
 |  
 |  ndim
 |      number of array dimensions
 |  
 |  real
 |      real part of scalar
 |  
 |  shape
 |      tuple of array dimensions
 |  
 |  size
 |      number of elements in the gentype
 |  
 |  strides
 |      tuple of bytes steps in each dimension
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from generic:
 |  
 |  __hash__ = None
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg.decomp.iscomplex,linalg.decomp,iscomplex,"Python Library Documentation: function iscomplex in module numpy.lib.type_check

iscomplex(x)
    Returns a bool array, where True if input element is complex.
    
    What is tested is whether the input has a non-zero imaginary part, not if
    the input type is complex.
    
    Parameters
    ----------
    x : array_like
        Input array.
    
    Returns
    -------
    out : ndarray of bools
        Output array.
    
    See Also
    --------
    isreal
    iscomplexobj : Return True if x is a complex type or an array of complex
                   numbers.
    
    Examples
    --------
    >>> np.iscomplex([1+1j, 1+0j, 4.5, 3, 2, 2j])
    array([ True, False, False, False, False,  True])
",function,"('(x)',)",scipy,1.1.0,scipy.linalg.decomp.iscomplex,linalg.decomp,iscomplex,"Python Library Documentation: function iscomplex in module numpy.lib.type_check

iscomplex(x)
    Returns a bool array, where True if input element is complex.
    
    What is tested is whether the input has a non-zero imaginary part, not if
    the input type is complex.
    
    Parameters
    ----------
    x : array_like
        Input array.
    
    Returns
    -------
    out : ndarray of bools
        Output array.
    
    See Also
    --------
    isreal
    iscomplexobj : Return True if x is a complex type or an array of complex
                   numbers.
    
    Examples
    --------
    >>> np.iscomplex([1+1j, 1+0j, 4.5, 3, 2, 2j])
    array([ True, False, False, False, False,  True])
",function,"('x',)","(nan,)","(nan,)","('arg_info',)","('(x)',)"
scipy,1.1.0,scipy.linalg.decomp.iscomplexobj,linalg.decomp,iscomplexobj,"Python Library Documentation: function iscomplexobj in module numpy.lib.type_check

iscomplexobj(x)
    Check for a complex type or an array of complex numbers.
    
    The type of the input is checked, not the value. Even if the input
    has an imaginary part equal to zero, `iscomplexobj` evaluates to True.
    
    Parameters
    ----------
    x : any
        The input can be of any type and shape.
    
    Returns
    -------
    iscomplexobj : bool
        The return value, True if `x` is of a complex type or has at least
        one complex element.
    
    See Also
    --------
    isrealobj, iscomplex
    
    Examples
    --------
    >>> np.iscomplexobj(1)
    False
    >>> np.iscomplexobj(1+0j)
    True
    >>> np.iscomplexobj([3, 1+0j, True])
    True
",function,"('(x)',)",scipy,1.1.0,scipy.linalg.decomp.iscomplexobj,linalg.decomp,iscomplexobj,"Python Library Documentation: function iscomplexobj in module numpy.lib.type_check

iscomplexobj(x)
    Check for a complex type or an array of complex numbers.
    
    The type of the input is checked, not the value. Even if the input
    has an imaginary part equal to zero, `iscomplexobj` evaluates to True.
    
    Parameters
    ----------
    x : any
        The input can be of any type and shape.
    
    Returns
    -------
    iscomplexobj : bool
        The return value, True if `x` is of a complex type or has at least
        one complex element.
    
    See Also
    --------
    isrealobj, iscomplex
    
    Examples
    --------
    >>> np.iscomplexobj(1)
    False
    >>> np.iscomplexobj(1+0j)
    True
    >>> np.iscomplexobj([3, 1+0j, True])
    True
",function,"('x',)","(nan,)","(nan,)","('arg_info',)","('(x)',)"
scipy,1.1.0,scipy.linalg.decomp.nonzero,linalg.decomp,nonzero,"Python Library Documentation: function nonzero in module numpy.core.fromnumeric

nonzero(a)
    Return the indices of the elements that are non-zero.
    
    Returns a tuple of arrays, one for each dimension of `a`,
    containing the indices of the non-zero elements in that
    dimension. The values in `a` are always tested and returned in
    row-major, C-style order. The corresponding non-zero
    values can be obtained with::
    
        a[nonzero(a)]
    
    To group the indices by element, rather than dimension, use::
    
        transpose(nonzero(a))
    
    The result of this is always a 2-D array, with a row for
    each non-zero element.
    
    Parameters
    ----------
    a : array_like
        Input array.
    
    Returns
    -------
    tuple_of_arrays : tuple
        Indices of elements that are non-zero.
    
    See Also
    --------
    flatnonzero :
        Return indices that are non-zero in the flattened version of the input
        array.
    ndarray.nonzero :
        Equivalent ndarray method.
    count_nonzero :
        Counts the number of non-zero elements in the input array.
    
    Examples
    --------
    >>> x = np.array([[1,0,0], [0,2,0], [1,1,0]])
    >>> x
    array([[1, 0, 0],
           [0, 2, 0],
           [1, 1, 0]])
    >>> np.nonzero(x)
    (array([0, 1, 2, 2]), array([0, 1, 0, 1]))
    
    >>> x[np.nonzero(x)]
    array([1, 2, 1, 1])
    >>> np.transpose(np.nonzero(x))
    array([[0, 0],
           [1, 1],
           [2, 0],
           [2, 1])
    
    A common use for ``nonzero`` is to find the indices of an array, where
    a condition is True.  Given an array `a`, the condition `a` > 3 is a
    boolean array and since False is interpreted as 0, np.nonzero(a > 3)
    yields the indices of the `a` where the condition is true.
    
    >>> a = np.array([[1,2,3],[4,5,6],[7,8,9]])
    >>> a > 3
    array([[False, False, False],
           [ True,  True,  True],
           [ True,  True,  True]])
    >>> np.nonzero(a > 3)
    (array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))
    
    The ``nonzero`` method of the boolean array can also be called.
    
    >>> (a > 3).nonzero()
    (array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))
",function,"('(a)',)",scipy,1.1.0,scipy.linalg.decomp.nonzero,linalg.decomp,nonzero,"Python Library Documentation: function nonzero in module numpy.core.fromnumeric

nonzero(a)
    Return the indices of the elements that are non-zero.
    
    Returns a tuple of arrays, one for each dimension of `a`,
    containing the indices of the non-zero elements in that
    dimension. The values in `a` are always tested and returned in
    row-major, C-style order. The corresponding non-zero
    values can be obtained with::
    
        a[nonzero(a)]
    
    To group the indices by element, rather than dimension, use::
    
        transpose(nonzero(a))
    
    The result of this is always a 2-D array, with a row for
    each non-zero element.
    
    Parameters
    ----------
    a : array_like
        Input array.
    
    Returns
    -------
    tuple_of_arrays : tuple
        Indices of elements that are non-zero.
    
    See Also
    --------
    flatnonzero :
        Return indices that are non-zero in the flattened version of the input
        array.
    ndarray.nonzero :
        Equivalent ndarray method.
    count_nonzero :
        Counts the number of non-zero elements in the input array.
    
    Examples
    --------
    >>> x = np.array([[1,0,0], [0,2,0], [1,1,0]])
    >>> x
    array([[1, 0, 0],
           [0, 2, 0],
           [1, 1, 0]])
    >>> np.nonzero(x)
    (array([0, 1, 2, 2]), array([0, 1, 0, 1]))
    
    >>> x[np.nonzero(x)]
    array([1, 2, 1, 1])
    >>> np.transpose(np.nonzero(x))
    array([[0, 0],
           [1, 1],
           [2, 0],
           [2, 1])
    
    A common use for ``nonzero`` is to find the indices of an array, where
    a condition is True.  Given an array `a`, the condition `a` > 3 is a
    boolean array and since False is interpreted as 0, np.nonzero(a > 3)
    yields the indices of the `a` where the condition is true.
    
    >>> a = np.array([[1,2,3],[4,5,6],[7,8,9]])
    >>> a > 3
    array([[False, False, False],
           [ True,  True,  True],
           [ True,  True,  True]])
    >>> np.nonzero(a > 3)
    (array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))
    
    The ``nonzero`` method of the boolean array can also be called.
    
    >>> (a > 3).nonzero()
    (array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))
",function,"('a',)","(nan,)","(nan,)","('arg_info',)","('(a)',)"
scipy,1.1.0,scipy.linalg.decomp.norm,linalg.decomp,norm,"Python Library Documentation: function norm in module scipy.linalg.misc

norm(a, ord=None, axis=None, keepdims=False)
    Matrix or vector norm.
    
    This function is able to return one of seven different matrix norms,
    or one of an infinite number of vector norms (described below), depending
    on the value of the ``ord`` parameter.
    
    Parameters
    ----------
    a : (M,) or (M, N) array_like
        Input array.  If `axis` is None, `a` must be 1-D or 2-D.
    ord : {non-zero int, inf, -inf, 'fro'}, optional
        Order of the norm (see table under ``Notes``). inf means numpy's
        `inf` object
    axis : {int, 2-tuple of ints, None}, optional
        If `axis` is an integer, it specifies the axis of `a` along which to
        compute the vector norms.  If `axis` is a 2-tuple, it specifies the
        axes that hold 2-D matrices, and the matrix norms of these matrices
        are computed.  If `axis` is None then either a vector norm (when `a`
        is 1-D) or a matrix norm (when `a` is 2-D) is returned.
    keepdims : bool, optional
        If this is set to True, the axes which are normed over are left in the
        result as dimensions with size one.  With this option the result will
        broadcast correctly against the original `a`.
    
    Returns
    -------
    n : float or ndarray
        Norm of the matrix or vector(s).
    
    Notes
    -----
    For values of ``ord <= 0``, the result is, strictly speaking, not a
    mathematical 'norm', but it may still be useful for various numerical
    purposes.
    
    The following norms can be calculated:
    
    =====  ============================  ==========================
    ord    norm for matrices             norm for vectors
    =====  ============================  ==========================
    None   Frobenius norm                2-norm
    'fro'  Frobenius norm                --
    inf    max(sum(abs(x), axis=1))      max(abs(x))
    -inf   min(sum(abs(x), axis=1))      min(abs(x))
    0      --                            sum(x != 0)
    1      max(sum(abs(x), axis=0))      as below
    -1     min(sum(abs(x), axis=0))      as below
    2      2-norm (largest sing. value)  as below
    -2     smallest singular value       as below
    other  --                            sum(abs(x)**ord)**(1./ord)
    =====  ============================  ==========================
    
    The Frobenius norm is given by [1]_:
    
        :math:`||A||_F = [\sum_{i,j} abs(a_{i,j})^2]^{1/2}`
    
    The ``axis`` and ``keepdims`` arguments are passed directly to
    ``numpy.linalg.norm`` and are only usable if they are supported
    by the version of numpy in use.
    
    References
    ----------
    .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*,
           Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15
    
    Examples
    --------
    >>> from scipy.linalg import norm
    >>> a = np.arange(9) - 4.0
    >>> a
    array([-4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.])
    >>> b = a.reshape((3, 3))
    >>> b
    array([[-4., -3., -2.],
           [-1.,  0.,  1.],
           [ 2.,  3.,  4.]])
    
    >>> norm(a)
    7.745966692414834
    >>> norm(b)
    7.745966692414834
    >>> norm(b, 'fro')
    7.745966692414834
    >>> norm(a, np.inf)
    4
    >>> norm(b, np.inf)
    9
    >>> norm(a, -np.inf)
    0
    >>> norm(b, -np.inf)
    2
    
    >>> norm(a, 1)
    20
    >>> norm(b, 1)
    7
    >>> norm(a, -1)
    -4.6566128774142013e-010
    >>> norm(b, -1)
    6
    >>> norm(a, 2)
    7.745966692414834
    >>> norm(b, 2)
    7.3484692283495345
    
    >>> norm(a, -2)
    0
    >>> norm(b, -2)
    1.8570331885190563e-016
    >>> norm(a, 3)
    5.8480354764257312
    >>> norm(a, -3)
    0
",function,"('(a, ord=None, axis=None, keepdims=False)',)",scipy,1.1.0,scipy.linalg.decomp.norm,linalg.decomp,norm,"Python Library Documentation: function norm in module scipy.linalg.misc

norm(a, ord=None, axis=None, keepdims=False)
    Matrix or vector norm.
    
    This function is able to return one of seven different matrix norms,
    or one of an infinite number of vector norms (described below), depending
    on the value of the ``ord`` parameter.
    
    Parameters
    ----------
    a : (M,) or (M, N) array_like
        Input array.  If `axis` is None, `a` must be 1-D or 2-D.
    ord : {non-zero int, inf, -inf, 'fro'}, optional
        Order of the norm (see table under ``Notes``). inf means numpy's
        `inf` object
    axis : {int, 2-tuple of ints, None}, optional
        If `axis` is an integer, it specifies the axis of `a` along which to
        compute the vector norms.  If `axis` is a 2-tuple, it specifies the
        axes that hold 2-D matrices, and the matrix norms of these matrices
        are computed.  If `axis` is None then either a vector norm (when `a`
        is 1-D) or a matrix norm (when `a` is 2-D) is returned.
    keepdims : bool, optional
        If this is set to True, the axes which are normed over are left in the
        result as dimensions with size one.  With this option the result will
        broadcast correctly against the original `a`.
    
    Returns
    -------
    n : float or ndarray
        Norm of the matrix or vector(s).
    
    Notes
    -----
    For values of ``ord <= 0``, the result is, strictly speaking, not a
    mathematical 'norm', but it may still be useful for various numerical
    purposes.
    
    The following norms can be calculated:
    
    =====  ============================  ==========================
    ord    norm for matrices             norm for vectors
    =====  ============================  ==========================
    None   Frobenius norm                2-norm
    'fro'  Frobenius norm                --
    inf    max(sum(abs(x), axis=1))      max(abs(x))
    -inf   min(sum(abs(x), axis=1))      min(abs(x))
    0      --                            sum(x != 0)
    1      max(sum(abs(x), axis=0))      as below
    -1     min(sum(abs(x), axis=0))      as below
    2      2-norm (largest sing. value)  as below
    -2     smallest singular value       as below
    other  --                            sum(abs(x)**ord)**(1./ord)
    =====  ============================  ==========================
    
    The Frobenius norm is given by [1]_:
    
        :math:`||A||_F = [\sum_{i,j} abs(a_{i,j})^2]^{1/2}`
    
    The ``axis`` and ``keepdims`` arguments are passed directly to
    ``numpy.linalg.norm`` and are only usable if they are supported
    by the version of numpy in use.
    
    References
    ----------
    .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*,
           Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15
    
    Examples
    --------
    >>> from scipy.linalg import norm
    >>> a = np.arange(9) - 4.0
    >>> a
    array([-4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.])
    >>> b = a.reshape((3, 3))
    >>> b
    array([[-4., -3., -2.],
           [-1.,  0.,  1.],
           [ 2.,  3.,  4.]])
    
    >>> norm(a)
    7.745966692414834
    >>> norm(b)
    7.745966692414834
    >>> norm(b, 'fro')
    7.745966692414834
    >>> norm(a, np.inf)
    4
    >>> norm(b, np.inf)
    9
    >>> norm(a, -np.inf)
    0
    >>> norm(b, -np.inf)
    2
    
    >>> norm(a, 1)
    20
    >>> norm(b, 1)
    7
    >>> norm(a, -1)
    -4.6566128774142013e-010
    >>> norm(b, -1)
    6
    >>> norm(a, 2)
    7.745966692414834
    >>> norm(b, 2)
    7.3484692283495345
    
    >>> norm(a, -2)
    0
    >>> norm(b, -2)
    1.8570331885190563e-016
    >>> norm(a, 3)
    5.8480354764257312
    >>> norm(a, -3)
    0
",function,"('a', 'ord', 'axis', 'keepdims')","(nan, None, None, False)","(nan, 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, ord=None, axis=None, keepdims=False)',)"
scipy,1.1.0,scipy.linalg.decomp.xrange,linalg.decomp,range,"Python Library Documentation: class range in module builtins

class range(object)
 |  range(stop) -> range object
 |  range(start, stop[, step]) -> range object
 |  
 |  Return an object that produces a sequence of integers from start (inclusive)
 |  to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.
 |  start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.
 |  These are exactly the valid indices for a list of 4 elements.
 |  When step is given, it specifies the increment (or decrement).
 |  
 |  Methods defined here:
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(...)
 |      Return a reverse iterator.
 |  
 |  count(...)
 |      rangeobject.count(value) -> integer -- return number of occurrences of value
 |  
 |  index(...)
 |      rangeobject.index(value, [start, [stop]]) -> integer -- return index of value.
 |      Raise ValueError if the value is not present.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  start
 |  
 |  step
 |  
 |  stop
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg.decomp.xrange,linalg.decomp,range,"Python Library Documentation: class range in module builtins

class range(object)
 |  range(stop) -> range object
 |  range(start, stop[, step]) -> range object
 |  
 |  Return an object that produces a sequence of integers from start (inclusive)
 |  to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.
 |  start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.
 |  These are exactly the valid indices for a list of 4 elements.
 |  When step is given, it specifies the increment (or decrement).
 |  
 |  Methods defined here:
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(...)
 |      Return a reverse iterator.
 |  
 |  count(...)
 |      rangeobject.count(value) -> integer -- return number of occurrences of value
 |  
 |  index(...)
 |      rangeobject.index(value, [start, [stop]]) -> integer -- return index of value.
 |      Raise ValueError if the value is not present.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  start
 |  
 |  step
 |  
 |  stop
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg.decomp_cholesky.LinAlgError,linalg.decomp_cholesky,LinAlgError,"Python Library Documentation: class LinAlgError in module numpy.linalg.linalg

class LinAlgError(builtins.Exception)
 |  Generic Python-exception-derived object raised by linalg functions.
 |  
 |  General purpose exception class, derived from Python's exception.Exception
 |  class, programmatically raised in linalg functions when a Linear
 |  Algebra-related condition would prevent further correct execution of the
 |  function.
 |  
 |  Parameters
 |  ----------
 |  None
 |  
 |  Examples
 |  --------
 |  >>> from numpy import linalg as LA
 |  >>> LA.inv(np.zeros((2,2)))
 |  Traceback (most recent call last):
 |    File ""<stdin>"", line 1, in <module>
 |    File ""...linalg.py"", line 350,
 |      in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
 |    File ""...linalg.py"", line 249,
 |      in solve
 |      raise LinAlgError('Singular matrix')
 |  numpy.linalg.LinAlgError: Singular matrix
 |  
 |  Method resolution order:
 |      LinAlgError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg.decomp_cholesky.LinAlgError,linalg.decomp_cholesky,LinAlgError,"Python Library Documentation: class LinAlgError in module numpy.linalg.linalg

class LinAlgError(builtins.Exception)
 |  Generic Python-exception-derived object raised by linalg functions.
 |  
 |  General purpose exception class, derived from Python's exception.Exception
 |  class, programmatically raised in linalg functions when a Linear
 |  Algebra-related condition would prevent further correct execution of the
 |  function.
 |  
 |  Parameters
 |  ----------
 |  None
 |  
 |  Examples
 |  --------
 |  >>> from numpy import linalg as LA
 |  >>> LA.inv(np.zeros((2,2)))
 |  Traceback (most recent call last):
 |    File ""<stdin>"", line 1, in <module>
 |    File ""...linalg.py"", line 350,
 |      in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
 |    File ""...linalg.py"", line 249,
 |      in solve
 |      raise LinAlgError('Singular matrix')
 |  numpy.linalg.LinAlgError: Singular matrix
 |  
 |  Method resolution order:
 |      LinAlgError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg.decomp_cholesky._cholesky,linalg.decomp_cholesky,_cholesky,"Python Library Documentation: function _cholesky in module scipy.linalg.decomp_cholesky

_cholesky(a, lower=False, overwrite_a=False, clean=True, check_finite=True)
    Common code for cholesky() and cho_factor().
",function,"('(a, lower=False, overwrite_a=False, clean=True, check_finite=True)',)",scipy,1.1.0,scipy.linalg.decomp_cholesky._cholesky,linalg.decomp_cholesky,_cholesky,"Python Library Documentation: function _cholesky in module scipy.linalg.decomp_cholesky

_cholesky(a, lower=False, overwrite_a=False, clean=True, check_finite=True)
    Common code for cholesky() and cho_factor().
",function,"('a', 'lower', 'overwrite_a', 'clean', 'check_finite')","(nan, False, False, True, True)","(nan, 'bool', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, lower=False, overwrite_a=False, clean=True, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.decomp_cholesky._datacopied,linalg.decomp_cholesky,_datacopied,"Python Library Documentation: function _datacopied in module scipy.linalg.misc

_datacopied(arr, original)
    Strict check for `arr` not sharing any data with `original`,
    under the assumption that arr = asarray(original)
",function,"('(arr, original)',)",scipy,1.1.0,scipy.linalg.decomp_cholesky._datacopied,linalg.decomp_cholesky,_datacopied,"Python Library Documentation: function _datacopied in module scipy.linalg.misc

_datacopied(arr, original)
    Strict check for `arr` not sharing any data with `original`,
    under the assumption that arr = asarray(original)
",function,"('arr', 'original')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(arr, original)',)"
scipy,1.1.0,scipy.linalg.decomp_cholesky.asarray,linalg.decomp_cholesky,asarray,"Python Library Documentation: function asarray in module numpy.core.numeric

asarray(a, dtype=None, order=None)
    Convert the input to an array.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
        Whether to use row-major (C-style) or
        column-major (Fortran-style) memory representation.
        Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray with matching dtype and order.  If `a` is a
        subclass of ndarray, a base class ndarray is returned.
    
    See Also
    --------
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    asarray_chkfinite : Similar function which checks input for NaNs and Infs.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array:
    
    >>> a = [1, 2]
    >>> np.asarray(a)
    array([1, 2])
    
    Existing arrays are not copied:
    
    >>> a = np.array([1, 2])
    >>> np.asarray(a) is a
    True
    
    If `dtype` is set, array is copied only if dtype does not match:
    
    >>> a = np.array([1, 2], dtype=np.float32)
    >>> np.asarray(a, dtype=np.float32) is a
    True
    >>> np.asarray(a, dtype=np.float64) is a
    False
    
    Contrary to `asanyarray`, ndarray subclasses are not passed through:
    
    >>> issubclass(np.matrix, np.ndarray)
    True
    >>> a = np.matrix([[1, 2]])
    >>> np.asarray(a) is a
    False
    >>> np.asanyarray(a) is a
    True
",function,"('(a, dtype=None, order=None)',)",scipy,1.1.0,scipy.linalg.decomp_cholesky.asarray,linalg.decomp_cholesky,asarray,"Python Library Documentation: function asarray in module numpy.core.numeric

asarray(a, dtype=None, order=None)
    Convert the input to an array.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
        Whether to use row-major (C-style) or
        column-major (Fortran-style) memory representation.
        Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray with matching dtype and order.  If `a` is a
        subclass of ndarray, a base class ndarray is returned.
    
    See Also
    --------
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    asarray_chkfinite : Similar function which checks input for NaNs and Infs.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array:
    
    >>> a = [1, 2]
    >>> np.asarray(a)
    array([1, 2])
    
    Existing arrays are not copied:
    
    >>> a = np.array([1, 2])
    >>> np.asarray(a) is a
    True
    
    If `dtype` is set, array is copied only if dtype does not match:
    
    >>> a = np.array([1, 2], dtype=np.float32)
    >>> np.asarray(a, dtype=np.float32) is a
    True
    >>> np.asarray(a, dtype=np.float64) is a
    False
    
    Contrary to `asanyarray`, ndarray subclasses are not passed through:
    
    >>> issubclass(np.matrix, np.ndarray)
    True
    >>> a = np.matrix([[1, 2]])
    >>> np.asarray(a) is a
    False
    >>> np.asanyarray(a) is a
    True
",function,"('a', 'dtype', 'order')","(nan, None, None)","(nan, 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(a, dtype=None, order=None)',)"
scipy,1.1.0,scipy.linalg.decomp_cholesky.asarray_chkfinite,linalg.decomp_cholesky,asarray_chkfinite,"Python Library Documentation: function asarray_chkfinite in module numpy.lib.function_base

asarray_chkfinite(a, dtype=None, order=None)
    Convert the input to an array, checking for NaNs or Infs.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.  Success requires no NaNs or Infs.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
         Whether to use row-major (C-style) or
         column-major (Fortran-style) memory representation.
         Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray.  If `a` is a subclass of ndarray, a base
        class ndarray is returned.
    
    Raises
    ------
    ValueError
        Raises ValueError if `a` contains NaN (Not a Number) or Inf (Infinity).
    
    See Also
    --------
    asarray : Create and array.
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array.  If all elements are finite
    ``asarray_chkfinite`` is identical to ``asarray``.
    
    >>> a = [1, 2]
    >>> np.asarray_chkfinite(a, dtype=float)
    array([1., 2.])
    
    Raises ValueError if array_like contains Nans or Infs.
    
    >>> a = [1, 2, np.inf]
    >>> try:
    ...     np.asarray_chkfinite(a)
    ... except ValueError:
    ...     print('ValueError')
    ...
    ValueError
",function,"('(a, dtype=None, order=None)',)",scipy,1.1.0,scipy.linalg.decomp_cholesky.asarray_chkfinite,linalg.decomp_cholesky,asarray_chkfinite,"Python Library Documentation: function asarray_chkfinite in module numpy.lib.function_base

asarray_chkfinite(a, dtype=None, order=None)
    Convert the input to an array, checking for NaNs or Infs.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.  Success requires no NaNs or Infs.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
         Whether to use row-major (C-style) or
         column-major (Fortran-style) memory representation.
         Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray.  If `a` is a subclass of ndarray, a base
        class ndarray is returned.
    
    Raises
    ------
    ValueError
        Raises ValueError if `a` contains NaN (Not a Number) or Inf (Infinity).
    
    See Also
    --------
    asarray : Create and array.
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array.  If all elements are finite
    ``asarray_chkfinite`` is identical to ``asarray``.
    
    >>> a = [1, 2]
    >>> np.asarray_chkfinite(a, dtype=float)
    array([1., 2.])
    
    Raises ValueError if array_like contains Nans or Infs.
    
    >>> a = [1, 2, np.inf]
    >>> try:
    ...     np.asarray_chkfinite(a)
    ... except ValueError:
    ...     print('ValueError')
    ...
    ValueError
",function,"('a', 'dtype', 'order')","(nan, None, None)","(nan, 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(a, dtype=None, order=None)',)"
scipy,1.1.0,scipy.linalg.decomp_cholesky.atleast_2d,linalg.decomp_cholesky,atleast_2d,"Python Library Documentation: function atleast_2d in module numpy.core.shape_base

atleast_2d(*arys)
    View inputs as arrays with at least two dimensions.
    
    Parameters
    ----------
    arys1, arys2, ... : array_like
        One or more array-like sequences.  Non-array inputs are converted
        to arrays.  Arrays that already have two or more dimensions are
        preserved.
    
    Returns
    -------
    res, res2, ... : ndarray
        An array, or list of arrays, each with ``a.ndim >= 2``.
        Copies are avoided where possible, and views with two or more
        dimensions are returned.
    
    See Also
    --------
    atleast_1d, atleast_3d
    
    Examples
    --------
    >>> np.atleast_2d(3.0)
    array([[ 3.]])
    
    >>> x = np.arange(3.0)
    >>> np.atleast_2d(x)
    array([[ 0.,  1.,  2.]])
    >>> np.atleast_2d(x).base is x
    True
    
    >>> np.atleast_2d(1, [1, 2], [[1, 2]])
    [array([[1]]), array([[1, 2]]), array([[1, 2]])]
",function,"('(*arys)',)",scipy,1.1.0,scipy.linalg.decomp_cholesky.atleast_2d,linalg.decomp_cholesky,atleast_2d,"Python Library Documentation: function atleast_2d in module numpy.core.shape_base

atleast_2d(*arys)
    View inputs as arrays with at least two dimensions.
    
    Parameters
    ----------
    arys1, arys2, ... : array_like
        One or more array-like sequences.  Non-array inputs are converted
        to arrays.  Arrays that already have two or more dimensions are
        preserved.
    
    Returns
    -------
    res, res2, ... : ndarray
        An array, or list of arrays, each with ``a.ndim >= 2``.
        Copies are avoided where possible, and views with two or more
        dimensions are returned.
    
    See Also
    --------
    atleast_1d, atleast_3d
    
    Examples
    --------
    >>> np.atleast_2d(3.0)
    array([[ 3.]])
    
    >>> x = np.arange(3.0)
    >>> np.atleast_2d(x)
    array([[ 0.,  1.,  2.]])
    >>> np.atleast_2d(x).base is x
    True
    
    >>> np.atleast_2d(1, [1, 2], [[1, 2]])
    [array([[1]]), array([[1, 2]]), array([[1, 2]])]
",function,(),(),(),(),"('(*arys)',)"
scipy,1.1.0,scipy.linalg.decomp_cholesky.cho_factor,linalg.decomp_cholesky,cho_factor,"Python Library Documentation: function cho_factor in module scipy.linalg.decomp_cholesky

cho_factor(a, lower=False, overwrite_a=False, check_finite=True)
    Compute the Cholesky decomposition of a matrix, to use in cho_solve
    
    Returns a matrix containing the Cholesky decomposition,
    ``A = L L*`` or ``A = U* U`` of a Hermitian positive-definite matrix `a`.
    The return value can be directly used as the first parameter to cho_solve.
    
    .. warning::
        The returned matrix also contains random data in the entries not
        used by the Cholesky decomposition. If you need to zero these
        entries, use the function `cholesky` instead.
    
    Parameters
    ----------
    a : (M, M) array_like
        Matrix to be decomposed
    lower : bool, optional
        Whether to compute the upper or lower triangular Cholesky factorization
        (Default: upper-triangular)
    overwrite_a : bool, optional
        Whether to overwrite data in a (may improve performance)
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    c : (M, M) ndarray
        Matrix whose upper or lower triangle contains the Cholesky factor
        of `a`. Other parts of the matrix contain random data.
    lower : bool
        Flag indicating whether the factor is in the lower or upper triangle
    
    Raises
    ------
    LinAlgError
        Raised if decomposition fails.
    
    See also
    --------
    cho_solve : Solve a linear set equations using the Cholesky factorization
                of a matrix.
    
    Examples
    --------
    >>> from scipy.linalg import cho_factor
    >>> A = np.array([[9, 3, 1, 5], [3, 7, 5, 1], [1, 5, 9, 2], [5, 1, 2, 6]])
    >>> c, low = cho_factor(A)
    >>> c
    array([[3.        , 1.        , 0.33333333, 1.66666667],
           [3.        , 2.44948974, 1.90515869, -0.27216553],
           [1.        , 5.        , 2.29330749, 0.8559528 ],
           [5.        , 1.        , 2.        , 1.55418563]])
    >>> np.allclose(np.triu(c).T @ np. triu(c) - A, np.zeros((4, 4)))
    True
",function,"('(a, lower=False, overwrite_a=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.decomp_cholesky.cho_factor,linalg.decomp_cholesky,cho_factor,"Python Library Documentation: function cho_factor in module scipy.linalg.decomp_cholesky

cho_factor(a, lower=False, overwrite_a=False, check_finite=True)
    Compute the Cholesky decomposition of a matrix, to use in cho_solve
    
    Returns a matrix containing the Cholesky decomposition,
    ``A = L L*`` or ``A = U* U`` of a Hermitian positive-definite matrix `a`.
    The return value can be directly used as the first parameter to cho_solve.
    
    .. warning::
        The returned matrix also contains random data in the entries not
        used by the Cholesky decomposition. If you need to zero these
        entries, use the function `cholesky` instead.
    
    Parameters
    ----------
    a : (M, M) array_like
        Matrix to be decomposed
    lower : bool, optional
        Whether to compute the upper or lower triangular Cholesky factorization
        (Default: upper-triangular)
    overwrite_a : bool, optional
        Whether to overwrite data in a (may improve performance)
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    c : (M, M) ndarray
        Matrix whose upper or lower triangle contains the Cholesky factor
        of `a`. Other parts of the matrix contain random data.
    lower : bool
        Flag indicating whether the factor is in the lower or upper triangle
    
    Raises
    ------
    LinAlgError
        Raised if decomposition fails.
    
    See also
    --------
    cho_solve : Solve a linear set equations using the Cholesky factorization
                of a matrix.
    
    Examples
    --------
    >>> from scipy.linalg import cho_factor
    >>> A = np.array([[9, 3, 1, 5], [3, 7, 5, 1], [1, 5, 9, 2], [5, 1, 2, 6]])
    >>> c, low = cho_factor(A)
    >>> c
    array([[3.        , 1.        , 0.33333333, 1.66666667],
           [3.        , 2.44948974, 1.90515869, -0.27216553],
           [1.        , 5.        , 2.29330749, 0.8559528 ],
           [5.        , 1.        , 2.        , 1.55418563]])
    >>> np.allclose(np.triu(c).T @ np. triu(c) - A, np.zeros((4, 4)))
    True
",function,"('a', 'lower', 'overwrite_a', 'check_finite')","(nan, False, False, True)","(nan, 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, lower=False, overwrite_a=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.decomp_cholesky.cho_solve,linalg.decomp_cholesky,cho_solve,"Python Library Documentation: function cho_solve in module scipy.linalg.decomp_cholesky

cho_solve(c_and_lower, b, overwrite_b=False, check_finite=True)
    Solve the linear equations A x = b, given the Cholesky factorization of A.
    
    Parameters
    ----------
    (c, lower) : tuple, (array, bool)
        Cholesky factorization of a, as given by cho_factor
    b : array
        Right-hand side
    overwrite_b : bool, optional
        Whether to overwrite data in b (may improve performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : array
        The solution to the system A x = b
    
    See also
    --------
    cho_factor : Cholesky factorization of a matrix
    
    Examples
    --------
    >>> from scipy.linalg import cho_factor, cho_solve
    >>> A = np.array([[9, 3, 1, 5], [3, 7, 5, 1], [1, 5, 9, 2], [5, 1, 2, 6]])
    >>> c, low = cho_factor(A)
    >>> x = cho_solve((c, low), [1, 1, 1, 1])
    >>> np.allclose(A @ x - [1, 1, 1, 1], np.zeros(4))
    True
",function,"('(c_and_lower, b, overwrite_b=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.decomp_cholesky.cho_solve,linalg.decomp_cholesky,cho_solve,"Python Library Documentation: function cho_solve in module scipy.linalg.decomp_cholesky

cho_solve(c_and_lower, b, overwrite_b=False, check_finite=True)
    Solve the linear equations A x = b, given the Cholesky factorization of A.
    
    Parameters
    ----------
    (c, lower) : tuple, (array, bool)
        Cholesky factorization of a, as given by cho_factor
    b : array
        Right-hand side
    overwrite_b : bool, optional
        Whether to overwrite data in b (may improve performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : array
        The solution to the system A x = b
    
    See also
    --------
    cho_factor : Cholesky factorization of a matrix
    
    Examples
    --------
    >>> from scipy.linalg import cho_factor, cho_solve
    >>> A = np.array([[9, 3, 1, 5], [3, 7, 5, 1], [1, 5, 9, 2], [5, 1, 2, 6]])
    >>> c, low = cho_factor(A)
    >>> x = cho_solve((c, low), [1, 1, 1, 1])
    >>> np.allclose(A @ x - [1, 1, 1, 1], np.zeros(4))
    True
",function,"('c_and_lower', 'b', 'overwrite_b', 'check_finite')","(nan, nan, False, True)","(nan, nan, 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(c_and_lower, b, overwrite_b=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.decomp_cholesky.cho_solve_banded,linalg.decomp_cholesky,cho_solve_banded,"Python Library Documentation: function cho_solve_banded in module scipy.linalg.decomp_cholesky

cho_solve_banded(cb_and_lower, b, overwrite_b=False, check_finite=True)
    Solve the linear equations ``A x = b``, given the Cholesky factorization of
    the banded hermitian ``A``.
    
    Parameters
    ----------
    (cb, lower) : tuple, (ndarray, bool)
        `cb` is the Cholesky factorization of A, as given by cholesky_banded.
        `lower` must be the same value that was given to cholesky_banded.
    b : array_like
        Right-hand side
    overwrite_b : bool, optional
        If True, the function will overwrite the values in `b`.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : array
        The solution to the system A x = b
    
    See also
    --------
    cholesky_banded : Cholesky factorization of a banded matrix
    
    Notes
    -----
    
    .. versionadded:: 0.8.0
    
    Examples
    --------
    >>> from scipy.linalg import cholesky_banded, cho_solve_banded
    >>> Ab = np.array([[0, 0, 1j, 2, 3j], [0, -1, -2, 3, 4], [9, 8, 7, 6, 9]])
    >>> A = np.diag(Ab[0,2:], k=2) + np.diag(Ab[1,1:], k=1)
    >>> A = A + A.conj().T + np.diag(Ab[2, :])
    >>> c = cholesky_banded(Ab)
    >>> x = cho_solve_banded((c, False), np.ones(5))
    >>> np.allclose(A @ x - np.ones(5), np.zeros(5))
    True
",function,"('(cb_and_lower, b, overwrite_b=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.decomp_cholesky.cho_solve_banded,linalg.decomp_cholesky,cho_solve_banded,"Python Library Documentation: function cho_solve_banded in module scipy.linalg.decomp_cholesky

cho_solve_banded(cb_and_lower, b, overwrite_b=False, check_finite=True)
    Solve the linear equations ``A x = b``, given the Cholesky factorization of
    the banded hermitian ``A``.
    
    Parameters
    ----------
    (cb, lower) : tuple, (ndarray, bool)
        `cb` is the Cholesky factorization of A, as given by cholesky_banded.
        `lower` must be the same value that was given to cholesky_banded.
    b : array_like
        Right-hand side
    overwrite_b : bool, optional
        If True, the function will overwrite the values in `b`.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : array
        The solution to the system A x = b
    
    See also
    --------
    cholesky_banded : Cholesky factorization of a banded matrix
    
    Notes
    -----
    
    .. versionadded:: 0.8.0
    
    Examples
    --------
    >>> from scipy.linalg import cholesky_banded, cho_solve_banded
    >>> Ab = np.array([[0, 0, 1j, 2, 3j], [0, -1, -2, 3, 4], [9, 8, 7, 6, 9]])
    >>> A = np.diag(Ab[0,2:], k=2) + np.diag(Ab[1,1:], k=1)
    >>> A = A + A.conj().T + np.diag(Ab[2, :])
    >>> c = cholesky_banded(Ab)
    >>> x = cho_solve_banded((c, False), np.ones(5))
    >>> np.allclose(A @ x - np.ones(5), np.zeros(5))
    True
",function,"('cb_and_lower', 'b', 'overwrite_b', 'check_finite')","(nan, nan, False, True)","(nan, nan, 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(cb_and_lower, b, overwrite_b=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.decomp_cholesky.cholesky,linalg.decomp_cholesky,cholesky,"Python Library Documentation: function cholesky in module scipy.linalg.decomp_cholesky

cholesky(a, lower=False, overwrite_a=False, check_finite=True)
    Compute the Cholesky decomposition of a matrix.
    
    Returns the Cholesky decomposition, :math:`A = L L^*` or
    :math:`A = U^* U` of a Hermitian positive-definite matrix A.
    
    Parameters
    ----------
    a : (M, M) array_like
        Matrix to be decomposed
    lower : bool, optional
        Whether to compute the upper or lower triangular Cholesky
        factorization.  Default is upper-triangular.
    overwrite_a : bool, optional
        Whether to overwrite data in `a` (may improve performance).
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    c : (M, M) ndarray
        Upper- or lower-triangular Cholesky factor of `a`.
    
    Raises
    ------
    LinAlgError : if decomposition fails.
    
    Examples
    --------
    >>> from scipy.linalg import cholesky
    >>> a = np.array([[1,-2j],[2j,5]])
    >>> L = cholesky(a, lower=True)
    >>> L
    array([[ 1.+0.j,  0.+0.j],
           [ 0.+2.j,  1.+0.j]])
    >>> L @ L.T.conj()
    array([[ 1.+0.j,  0.-2.j],
           [ 0.+2.j,  5.+0.j]])
",function,"('(a, lower=False, overwrite_a=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.decomp_cholesky.cholesky,linalg.decomp_cholesky,cholesky,"Python Library Documentation: function cholesky in module scipy.linalg.decomp_cholesky

cholesky(a, lower=False, overwrite_a=False, check_finite=True)
    Compute the Cholesky decomposition of a matrix.
    
    Returns the Cholesky decomposition, :math:`A = L L^*` or
    :math:`A = U^* U` of a Hermitian positive-definite matrix A.
    
    Parameters
    ----------
    a : (M, M) array_like
        Matrix to be decomposed
    lower : bool, optional
        Whether to compute the upper or lower triangular Cholesky
        factorization.  Default is upper-triangular.
    overwrite_a : bool, optional
        Whether to overwrite data in `a` (may improve performance).
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    c : (M, M) ndarray
        Upper- or lower-triangular Cholesky factor of `a`.
    
    Raises
    ------
    LinAlgError : if decomposition fails.
    
    Examples
    --------
    >>> from scipy.linalg import cholesky
    >>> a = np.array([[1,-2j],[2j,5]])
    >>> L = cholesky(a, lower=True)
    >>> L
    array([[ 1.+0.j,  0.+0.j],
           [ 0.+2.j,  1.+0.j]])
    >>> L @ L.T.conj()
    array([[ 1.+0.j,  0.-2.j],
           [ 0.+2.j,  5.+0.j]])
",function,"('a', 'lower', 'overwrite_a', 'check_finite')","(nan, False, False, True)","(nan, 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, lower=False, overwrite_a=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.decomp_cholesky.cholesky_banded,linalg.decomp_cholesky,cholesky_banded,"Python Library Documentation: function cholesky_banded in module scipy.linalg.decomp_cholesky

cholesky_banded(ab, overwrite_ab=False, lower=False, check_finite=True)
    Cholesky decompose a banded Hermitian positive-definite matrix
    
    The matrix a is stored in ab either in lower diagonal or upper
    diagonal ordered form::
    
        ab[u + i - j, j] == a[i,j]        (if upper form; i <= j)
        ab[    i - j, j] == a[i,j]        (if lower form; i >= j)
    
    Example of ab (shape of a is (6,6), u=2)::
    
        upper form:
        *   *   a02 a13 a24 a35
        *   a01 a12 a23 a34 a45
        a00 a11 a22 a33 a44 a55
    
        lower form:
        a00 a11 a22 a33 a44 a55
        a10 a21 a32 a43 a54 *
        a20 a31 a42 a53 *   *
    
    Parameters
    ----------
    ab : (u + 1, M) array_like
        Banded matrix
    overwrite_ab : bool, optional
        Discard data in ab (may enhance performance)
    lower : bool, optional
        Is the matrix in the lower form. (Default is upper form)
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    c : (u + 1, M) ndarray
        Cholesky factorization of a, in the same banded format as ab
    
    Examples
    --------
    >>> from scipy.linalg import cholesky_banded
    >>> from numpy import allclose, zeros, diag
    >>> Ab = np.array([[0, 0, 1j, 2, 3j], [0, -1, -2, 3, 4], [9, 8, 7, 6, 9]])
    >>> A = np.diag(Ab[0,2:], k=2) + np.diag(Ab[1,1:], k=1)
    >>> A = A + A.conj().T + np.diag(Ab[2, :])
    >>> c = cholesky_banded(Ab)
    >>> C = np.diag(c[0, 2:], k=2) + np.diag(c[1, 1:], k=1) + np.diag(c[2, :])
    >>> np.allclose(C.conj().T @ C - A, np.zeros((5, 5)))
    True
",function,"('(ab, overwrite_ab=False, lower=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.decomp_cholesky.cholesky_banded,linalg.decomp_cholesky,cholesky_banded,"Python Library Documentation: function cholesky_banded in module scipy.linalg.decomp_cholesky

cholesky_banded(ab, overwrite_ab=False, lower=False, check_finite=True)
    Cholesky decompose a banded Hermitian positive-definite matrix
    
    The matrix a is stored in ab either in lower diagonal or upper
    diagonal ordered form::
    
        ab[u + i - j, j] == a[i,j]        (if upper form; i <= j)
        ab[    i - j, j] == a[i,j]        (if lower form; i >= j)
    
    Example of ab (shape of a is (6,6), u=2)::
    
        upper form:
        *   *   a02 a13 a24 a35
        *   a01 a12 a23 a34 a45
        a00 a11 a22 a33 a44 a55
    
        lower form:
        a00 a11 a22 a33 a44 a55
        a10 a21 a32 a43 a54 *
        a20 a31 a42 a53 *   *
    
    Parameters
    ----------
    ab : (u + 1, M) array_like
        Banded matrix
    overwrite_ab : bool, optional
        Discard data in ab (may enhance performance)
    lower : bool, optional
        Is the matrix in the lower form. (Default is upper form)
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    c : (u + 1, M) ndarray
        Cholesky factorization of a, in the same banded format as ab
    
    Examples
    --------
    >>> from scipy.linalg import cholesky_banded
    >>> from numpy import allclose, zeros, diag
    >>> Ab = np.array([[0, 0, 1j, 2, 3j], [0, -1, -2, 3, 4], [9, 8, 7, 6, 9]])
    >>> A = np.diag(Ab[0,2:], k=2) + np.diag(Ab[1,1:], k=1)
    >>> A = A + A.conj().T + np.diag(Ab[2, :])
    >>> c = cholesky_banded(Ab)
    >>> C = np.diag(c[0, 2:], k=2) + np.diag(c[1, 1:], k=1) + np.diag(c[2, :])
    >>> np.allclose(C.conj().T @ C - A, np.zeros((5, 5)))
    True
",function,"('ab', 'overwrite_ab', 'lower', 'check_finite')","(nan, False, False, True)","(nan, 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(ab, overwrite_ab=False, lower=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.decomp_cholesky.get_lapack_funcs,linalg.decomp_cholesky,get_lapack_funcs,"Python Library Documentation: function get_lapack_funcs in module scipy.linalg.lapack

get_lapack_funcs(names, arrays=(), dtype=None)
    Return available LAPACK function objects from names.
    
    Arrays are used to determine the optimal prefix of LAPACK routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of LAPACK functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of LAPACK
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In LAPACK, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively, and
    are stored in attribute ``typecode`` of the returned functions.
    
    Examples
    --------
    Suppose we would like to use '?lange' routine which computes the selected
    norm of an array. We pass our array in order to get the correct 'lange'
    flavor.
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_lange = LA.get_lapack_funcs('lange', (a,))
    >>> x_lange.typecode
    'd'
    >>> x_lange = LA.get_lapack_funcs('lange',(a*1j,))
    >>> x_lange.typecode
    'z'
    
    Several LAPACK routines work best when its internal WORK array has
    the optimal size (big enough for fast computation and small enough to
    avoid waste of memory). This size is determined also by a dedicated query
    to the function which is often wrapped as a standalone function and
    commonly denoted as ``###_lwork``. Below is an example for ``?sysv``
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(1000,1000)
    >>> b = np.random.rand(1000,1)*1j
    >>> # We pick up zsysv and zsysv_lwork due to b array
    ... xsysv, xlwork = LA.get_lapack_funcs(('sysv', 'sysv_lwork'), (a, b))
    >>> opt_lwork, _ = xlwork(a.shape[0])  # returns a complex for 'z' prefix
    >>> udut, ipiv, x, info = xsysv(a, b, lwork=int(opt_lwork.real))
",function,"('(names, arrays=(), dtype=None)',)",scipy,1.1.0,scipy.linalg.decomp_cholesky.get_lapack_funcs,linalg.decomp_cholesky,get_lapack_funcs,"Python Library Documentation: function get_lapack_funcs in module scipy.linalg.lapack

get_lapack_funcs(names, arrays=(), dtype=None)
    Return available LAPACK function objects from names.
    
    Arrays are used to determine the optimal prefix of LAPACK routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of LAPACK functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of LAPACK
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In LAPACK, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively, and
    are stored in attribute ``typecode`` of the returned functions.
    
    Examples
    --------
    Suppose we would like to use '?lange' routine which computes the selected
    norm of an array. We pass our array in order to get the correct 'lange'
    flavor.
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_lange = LA.get_lapack_funcs('lange', (a,))
    >>> x_lange.typecode
    'd'
    >>> x_lange = LA.get_lapack_funcs('lange',(a*1j,))
    >>> x_lange.typecode
    'z'
    
    Several LAPACK routines work best when its internal WORK array has
    the optimal size (big enough for fast computation and small enough to
    avoid waste of memory). This size is determined also by a dedicated query
    to the function which is often wrapped as a standalone function and
    commonly denoted as ``###_lwork``. Below is an example for ``?sysv``
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(1000,1000)
    >>> b = np.random.rand(1000,1)*1j
    >>> # We pick up zsysv and zsysv_lwork due to b array
    ... xsysv, xlwork = LA.get_lapack_funcs(('sysv', 'sysv_lwork'), (a, b))
    >>> opt_lwork, _ = xlwork(a.shape[0])  # returns a complex for 'z' prefix
    >>> udut, ipiv, x, info = xsysv(a, b, lwork=int(opt_lwork.real))
",function,"('names', 'arrays', 'dtype')","(nan, (), None)","(nan, 'tuple', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(names, arrays=(), dtype=None)',)"
scipy,1.1.0,scipy.linalg.decomp_lu.LinAlgWarning,linalg.decomp_lu,LinAlgWarning,"Python Library Documentation: class LinAlgWarning in module scipy.linalg.misc

class LinAlgWarning(builtins.RuntimeWarning)
 |  The warning emitted when a linear algebra related operation is close
 |  to fail conditions of the algorithm or loss of accuracy is expected.
 |  
 |  Method resolution order:
 |      LinAlgWarning
 |      builtins.RuntimeWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.RuntimeWarning:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg.decomp_lu.LinAlgWarning,linalg.decomp_lu,LinAlgWarning,"Python Library Documentation: class LinAlgWarning in module scipy.linalg.misc

class LinAlgWarning(builtins.RuntimeWarning)
 |  The warning emitted when a linear algebra related operation is close
 |  to fail conditions of the algorithm or loss of accuracy is expected.
 |  
 |  Method resolution order:
 |      LinAlgWarning
 |      builtins.RuntimeWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.RuntimeWarning:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg.decomp_lu._datacopied,linalg.decomp_lu,_datacopied,"Python Library Documentation: function _datacopied in module scipy.linalg.misc

_datacopied(arr, original)
    Strict check for `arr` not sharing any data with `original`,
    under the assumption that arr = asarray(original)
",function,"('(arr, original)',)",scipy,1.1.0,scipy.linalg.decomp_lu._datacopied,linalg.decomp_lu,_datacopied,"Python Library Documentation: function _datacopied in module scipy.linalg.misc

_datacopied(arr, original)
    Strict check for `arr` not sharing any data with `original`,
    under the assumption that arr = asarray(original)
",function,"('arr', 'original')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(arr, original)',)"
scipy,1.1.0,scipy.linalg.decomp_lu.asarray,linalg.decomp_lu,asarray,"Python Library Documentation: function asarray in module numpy.core.numeric

asarray(a, dtype=None, order=None)
    Convert the input to an array.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
        Whether to use row-major (C-style) or
        column-major (Fortran-style) memory representation.
        Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray with matching dtype and order.  If `a` is a
        subclass of ndarray, a base class ndarray is returned.
    
    See Also
    --------
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    asarray_chkfinite : Similar function which checks input for NaNs and Infs.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array:
    
    >>> a = [1, 2]
    >>> np.asarray(a)
    array([1, 2])
    
    Existing arrays are not copied:
    
    >>> a = np.array([1, 2])
    >>> np.asarray(a) is a
    True
    
    If `dtype` is set, array is copied only if dtype does not match:
    
    >>> a = np.array([1, 2], dtype=np.float32)
    >>> np.asarray(a, dtype=np.float32) is a
    True
    >>> np.asarray(a, dtype=np.float64) is a
    False
    
    Contrary to `asanyarray`, ndarray subclasses are not passed through:
    
    >>> issubclass(np.matrix, np.ndarray)
    True
    >>> a = np.matrix([[1, 2]])
    >>> np.asarray(a) is a
    False
    >>> np.asanyarray(a) is a
    True
",function,"('(a, dtype=None, order=None)',)",scipy,1.1.0,scipy.linalg.decomp_lu.asarray,linalg.decomp_lu,asarray,"Python Library Documentation: function asarray in module numpy.core.numeric

asarray(a, dtype=None, order=None)
    Convert the input to an array.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
        Whether to use row-major (C-style) or
        column-major (Fortran-style) memory representation.
        Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray with matching dtype and order.  If `a` is a
        subclass of ndarray, a base class ndarray is returned.
    
    See Also
    --------
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    asarray_chkfinite : Similar function which checks input for NaNs and Infs.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array:
    
    >>> a = [1, 2]
    >>> np.asarray(a)
    array([1, 2])
    
    Existing arrays are not copied:
    
    >>> a = np.array([1, 2])
    >>> np.asarray(a) is a
    True
    
    If `dtype` is set, array is copied only if dtype does not match:
    
    >>> a = np.array([1, 2], dtype=np.float32)
    >>> np.asarray(a, dtype=np.float32) is a
    True
    >>> np.asarray(a, dtype=np.float64) is a
    False
    
    Contrary to `asanyarray`, ndarray subclasses are not passed through:
    
    >>> issubclass(np.matrix, np.ndarray)
    True
    >>> a = np.matrix([[1, 2]])
    >>> np.asarray(a) is a
    False
    >>> np.asanyarray(a) is a
    True
",function,"('a', 'dtype', 'order')","(nan, None, None)","(nan, 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(a, dtype=None, order=None)',)"
scipy,1.1.0,scipy.linalg.decomp_lu.asarray_chkfinite,linalg.decomp_lu,asarray_chkfinite,"Python Library Documentation: function asarray_chkfinite in module numpy.lib.function_base

asarray_chkfinite(a, dtype=None, order=None)
    Convert the input to an array, checking for NaNs or Infs.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.  Success requires no NaNs or Infs.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
         Whether to use row-major (C-style) or
         column-major (Fortran-style) memory representation.
         Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray.  If `a` is a subclass of ndarray, a base
        class ndarray is returned.
    
    Raises
    ------
    ValueError
        Raises ValueError if `a` contains NaN (Not a Number) or Inf (Infinity).
    
    See Also
    --------
    asarray : Create and array.
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array.  If all elements are finite
    ``asarray_chkfinite`` is identical to ``asarray``.
    
    >>> a = [1, 2]
    >>> np.asarray_chkfinite(a, dtype=float)
    array([1., 2.])
    
    Raises ValueError if array_like contains Nans or Infs.
    
    >>> a = [1, 2, np.inf]
    >>> try:
    ...     np.asarray_chkfinite(a)
    ... except ValueError:
    ...     print('ValueError')
    ...
    ValueError
",function,"('(a, dtype=None, order=None)',)",scipy,1.1.0,scipy.linalg.decomp_lu.asarray_chkfinite,linalg.decomp_lu,asarray_chkfinite,"Python Library Documentation: function asarray_chkfinite in module numpy.lib.function_base

asarray_chkfinite(a, dtype=None, order=None)
    Convert the input to an array, checking for NaNs or Infs.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.  Success requires no NaNs or Infs.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
         Whether to use row-major (C-style) or
         column-major (Fortran-style) memory representation.
         Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray.  If `a` is a subclass of ndarray, a base
        class ndarray is returned.
    
    Raises
    ------
    ValueError
        Raises ValueError if `a` contains NaN (Not a Number) or Inf (Infinity).
    
    See Also
    --------
    asarray : Create and array.
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array.  If all elements are finite
    ``asarray_chkfinite`` is identical to ``asarray``.
    
    >>> a = [1, 2]
    >>> np.asarray_chkfinite(a, dtype=float)
    array([1., 2.])
    
    Raises ValueError if array_like contains Nans or Infs.
    
    >>> a = [1, 2, np.inf]
    >>> try:
    ...     np.asarray_chkfinite(a)
    ... except ValueError:
    ...     print('ValueError')
    ...
    ValueError
",function,"('a', 'dtype', 'order')","(nan, None, None)","(nan, 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(a, dtype=None, order=None)',)"
scipy,1.1.0,scipy.linalg.decomp_lu.get_flinalg_funcs,linalg.decomp_lu,get_flinalg_funcs,"Python Library Documentation: function get_flinalg_funcs in module scipy.linalg.flinalg

get_flinalg_funcs(names, arrays=(), debug=0)
    Return optimal available _flinalg function objects with
    names. arrays are used to determine optimal prefix.
",function,"('(names, arrays=(), debug=0)',)",scipy,1.1.0,scipy.linalg.decomp_lu.get_flinalg_funcs,linalg.decomp_lu,get_flinalg_funcs,"Python Library Documentation: function get_flinalg_funcs in module scipy.linalg.flinalg

get_flinalg_funcs(names, arrays=(), debug=0)
    Return optimal available _flinalg function objects with
    names. arrays are used to determine optimal prefix.
",function,"('names', 'arrays', 'debug')","(nan, (), 0)","(nan, 'tuple', 'int')","('arg_info', 'arg_info', 'arg_info')","('(names, arrays=(), debug=0)',)"
scipy,1.1.0,scipy.linalg.decomp_lu.get_lapack_funcs,linalg.decomp_lu,get_lapack_funcs,"Python Library Documentation: function get_lapack_funcs in module scipy.linalg.lapack

get_lapack_funcs(names, arrays=(), dtype=None)
    Return available LAPACK function objects from names.
    
    Arrays are used to determine the optimal prefix of LAPACK routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of LAPACK functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of LAPACK
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In LAPACK, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively, and
    are stored in attribute ``typecode`` of the returned functions.
    
    Examples
    --------
    Suppose we would like to use '?lange' routine which computes the selected
    norm of an array. We pass our array in order to get the correct 'lange'
    flavor.
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_lange = LA.get_lapack_funcs('lange', (a,))
    >>> x_lange.typecode
    'd'
    >>> x_lange = LA.get_lapack_funcs('lange',(a*1j,))
    >>> x_lange.typecode
    'z'
    
    Several LAPACK routines work best when its internal WORK array has
    the optimal size (big enough for fast computation and small enough to
    avoid waste of memory). This size is determined also by a dedicated query
    to the function which is often wrapped as a standalone function and
    commonly denoted as ``###_lwork``. Below is an example for ``?sysv``
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(1000,1000)
    >>> b = np.random.rand(1000,1)*1j
    >>> # We pick up zsysv and zsysv_lwork due to b array
    ... xsysv, xlwork = LA.get_lapack_funcs(('sysv', 'sysv_lwork'), (a, b))
    >>> opt_lwork, _ = xlwork(a.shape[0])  # returns a complex for 'z' prefix
    >>> udut, ipiv, x, info = xsysv(a, b, lwork=int(opt_lwork.real))
",function,"('(names, arrays=(), dtype=None)',)",scipy,1.1.0,scipy.linalg.decomp_lu.get_lapack_funcs,linalg.decomp_lu,get_lapack_funcs,"Python Library Documentation: function get_lapack_funcs in module scipy.linalg.lapack

get_lapack_funcs(names, arrays=(), dtype=None)
    Return available LAPACK function objects from names.
    
    Arrays are used to determine the optimal prefix of LAPACK routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of LAPACK functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of LAPACK
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In LAPACK, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively, and
    are stored in attribute ``typecode`` of the returned functions.
    
    Examples
    --------
    Suppose we would like to use '?lange' routine which computes the selected
    norm of an array. We pass our array in order to get the correct 'lange'
    flavor.
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_lange = LA.get_lapack_funcs('lange', (a,))
    >>> x_lange.typecode
    'd'
    >>> x_lange = LA.get_lapack_funcs('lange',(a*1j,))
    >>> x_lange.typecode
    'z'
    
    Several LAPACK routines work best when its internal WORK array has
    the optimal size (big enough for fast computation and small enough to
    avoid waste of memory). This size is determined also by a dedicated query
    to the function which is often wrapped as a standalone function and
    commonly denoted as ``###_lwork``. Below is an example for ``?sysv``
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(1000,1000)
    >>> b = np.random.rand(1000,1)*1j
    >>> # We pick up zsysv and zsysv_lwork due to b array
    ... xsysv, xlwork = LA.get_lapack_funcs(('sysv', 'sysv_lwork'), (a, b))
    >>> opt_lwork, _ = xlwork(a.shape[0])  # returns a complex for 'z' prefix
    >>> udut, ipiv, x, info = xsysv(a, b, lwork=int(opt_lwork.real))
",function,"('names', 'arrays', 'dtype')","(nan, (), None)","(nan, 'tuple', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(names, arrays=(), dtype=None)',)"
scipy,1.1.0,scipy.linalg.decomp_lu.lu,linalg.decomp_lu,lu,"Python Library Documentation: function lu in module scipy.linalg.decomp_lu

lu(a, permute_l=False, overwrite_a=False, check_finite=True)
    Compute pivoted LU decomposition of a matrix.
    
    The decomposition is::
    
        A = P L U
    
    where P is a permutation matrix, L lower triangular with unit
    diagonal elements, and U upper triangular.
    
    Parameters
    ----------
    a : (M, N) array_like
        Array to decompose
    permute_l : bool, optional
        Perform the multiplication P*L  (Default: do not permute)
    overwrite_a : bool, optional
        Whether to overwrite data in a (may improve performance)
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    **(If permute_l == False)**
    
    p : (M, M) ndarray
        Permutation matrix
    l : (M, K) ndarray
        Lower triangular or trapezoidal matrix with unit diagonal.
        K = min(M, N)
    u : (K, N) ndarray
        Upper triangular or trapezoidal matrix
    
    **(If permute_l == True)**
    
    pl : (M, K) ndarray
        Permuted L matrix.
        K = min(M, N)
    u : (K, N) ndarray
        Upper triangular or trapezoidal matrix
    
    Notes
    -----
    This is a LU factorization routine written for Scipy.
    
    Examples
    --------
    >>> from scipy.linalg import lu
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> p, l, u = lu(A)
    >>> np.allclose(A - p @ l @ u, np.zeros((4, 4)))
    True
",function,"('(a, permute_l=False, overwrite_a=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.decomp_lu.lu,linalg.decomp_lu,lu,"Python Library Documentation: function lu in module scipy.linalg.decomp_lu

lu(a, permute_l=False, overwrite_a=False, check_finite=True)
    Compute pivoted LU decomposition of a matrix.
    
    The decomposition is::
    
        A = P L U
    
    where P is a permutation matrix, L lower triangular with unit
    diagonal elements, and U upper triangular.
    
    Parameters
    ----------
    a : (M, N) array_like
        Array to decompose
    permute_l : bool, optional
        Perform the multiplication P*L  (Default: do not permute)
    overwrite_a : bool, optional
        Whether to overwrite data in a (may improve performance)
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    **(If permute_l == False)**
    
    p : (M, M) ndarray
        Permutation matrix
    l : (M, K) ndarray
        Lower triangular or trapezoidal matrix with unit diagonal.
        K = min(M, N)
    u : (K, N) ndarray
        Upper triangular or trapezoidal matrix
    
    **(If permute_l == True)**
    
    pl : (M, K) ndarray
        Permuted L matrix.
        K = min(M, N)
    u : (K, N) ndarray
        Upper triangular or trapezoidal matrix
    
    Notes
    -----
    This is a LU factorization routine written for Scipy.
    
    Examples
    --------
    >>> from scipy.linalg import lu
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> p, l, u = lu(A)
    >>> np.allclose(A - p @ l @ u, np.zeros((4, 4)))
    True
",function,"('a', 'permute_l', 'overwrite_a', 'check_finite')","(nan, False, False, True)","(nan, 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, permute_l=False, overwrite_a=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.decomp_lu.lu_factor,linalg.decomp_lu,lu_factor,"Python Library Documentation: function lu_factor in module scipy.linalg.decomp_lu

lu_factor(a, overwrite_a=False, check_finite=True)
    Compute pivoted LU decomposition of a matrix.
    
    The decomposition is::
    
        A = P L U
    
    where P is a permutation matrix, L lower triangular with unit
    diagonal elements, and U upper triangular.
    
    Parameters
    ----------
    a : (M, M) array_like
        Matrix to decompose
    overwrite_a : bool, optional
        Whether to overwrite data in A (may increase performance)
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    lu : (N, N) ndarray
        Matrix containing U in its upper triangle, and L in its lower triangle.
        The unit diagonal elements of L are not stored.
    piv : (N,) ndarray
        Pivot indices representing the permutation matrix P:
        row i of matrix was interchanged with row piv[i].
    
    See also
    --------
    lu_solve : solve an equation system using the LU factorization of a matrix
    
    Notes
    -----
    This is a wrapper to the ``*GETRF`` routines from LAPACK.
    
    Examples
    --------
    >>> from scipy.linalg import lu_factor
    >>> from numpy import tril, triu, allclose, zeros, eye
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> lu, piv = lu_factor(A)
    >>> piv
    array([2, 2, 3, 3], dtype=int32)
    
    Convert LAPACK's ``piv`` array to NumPy index and test the permutation 
    
    >>> piv_py = [2, 0, 3, 1]
    >>> L, U = np.tril(lu, k=-1) + np.eye(4), np.triu(lu)
    >>> np.allclose(A[piv_py] - L @ U, np.zeros((4, 4)))
    True
",function,"('(a, overwrite_a=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.decomp_lu.lu_factor,linalg.decomp_lu,lu_factor,"Python Library Documentation: function lu_factor in module scipy.linalg.decomp_lu

lu_factor(a, overwrite_a=False, check_finite=True)
    Compute pivoted LU decomposition of a matrix.
    
    The decomposition is::
    
        A = P L U
    
    where P is a permutation matrix, L lower triangular with unit
    diagonal elements, and U upper triangular.
    
    Parameters
    ----------
    a : (M, M) array_like
        Matrix to decompose
    overwrite_a : bool, optional
        Whether to overwrite data in A (may increase performance)
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    lu : (N, N) ndarray
        Matrix containing U in its upper triangle, and L in its lower triangle.
        The unit diagonal elements of L are not stored.
    piv : (N,) ndarray
        Pivot indices representing the permutation matrix P:
        row i of matrix was interchanged with row piv[i].
    
    See also
    --------
    lu_solve : solve an equation system using the LU factorization of a matrix
    
    Notes
    -----
    This is a wrapper to the ``*GETRF`` routines from LAPACK.
    
    Examples
    --------
    >>> from scipy.linalg import lu_factor
    >>> from numpy import tril, triu, allclose, zeros, eye
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> lu, piv = lu_factor(A)
    >>> piv
    array([2, 2, 3, 3], dtype=int32)
    
    Convert LAPACK's ``piv`` array to NumPy index and test the permutation 
    
    >>> piv_py = [2, 0, 3, 1]
    >>> L, U = np.tril(lu, k=-1) + np.eye(4), np.triu(lu)
    >>> np.allclose(A[piv_py] - L @ U, np.zeros((4, 4)))
    True
",function,"('a', 'overwrite_a', 'check_finite')","(nan, False, True)","(nan, 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info')","('(a, overwrite_a=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.decomp_lu.lu_solve,linalg.decomp_lu,lu_solve,"Python Library Documentation: function lu_solve in module scipy.linalg.decomp_lu

lu_solve(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True)
    Solve an equation system, a x = b, given the LU factorization of a
    
    Parameters
    ----------
    (lu, piv)
        Factorization of the coefficient matrix a, as given by lu_factor
    b : array
        Right-hand side
    trans : {0, 1, 2}, optional
        Type of system to solve:
    
        =====  =========
        trans  system
        =====  =========
        0      a x   = b
        1      a^T x = b
        2      a^H x = b
        =====  =========
    overwrite_b : bool, optional
        Whether to overwrite data in b (may increase performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : array
        Solution to the system
    
    See also
    --------
    lu_factor : LU factorize a matrix
    
    Examples
    --------
    >>> from scipy.linalg import lu_factor, lu_solve
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> b = np.array([1, 1, 1, 1])
    >>> lu, piv = lu_factor(A)
    >>> x = lu_solve((lu, piv), b)
    >>> np.allclose(A @ x - b, np.zeros((4,)))
    True
",function,"('(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.decomp_lu.lu_solve,linalg.decomp_lu,lu_solve,"Python Library Documentation: function lu_solve in module scipy.linalg.decomp_lu

lu_solve(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True)
    Solve an equation system, a x = b, given the LU factorization of a
    
    Parameters
    ----------
    (lu, piv)
        Factorization of the coefficient matrix a, as given by lu_factor
    b : array
        Right-hand side
    trans : {0, 1, 2}, optional
        Type of system to solve:
    
        =====  =========
        trans  system
        =====  =========
        0      a x   = b
        1      a^T x = b
        2      a^H x = b
        =====  =========
    overwrite_b : bool, optional
        Whether to overwrite data in b (may increase performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : array
        Solution to the system
    
    See also
    --------
    lu_factor : LU factorize a matrix
    
    Examples
    --------
    >>> from scipy.linalg import lu_factor, lu_solve
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> b = np.array([1, 1, 1, 1])
    >>> lu, piv = lu_factor(A)
    >>> x = lu_solve((lu, piv), b)
    >>> np.allclose(A @ x - b, np.zeros((4,)))
    True
",function,"('lu_and_piv', 'b', 'trans', 'overwrite_b', 'check_finite')","(nan, nan, 0, False, True)","(nan, nan, 'int', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.decomp_qr._datacopied,linalg.decomp_qr,_datacopied,"Python Library Documentation: function _datacopied in module scipy.linalg.misc

_datacopied(arr, original)
    Strict check for `arr` not sharing any data with `original`,
    under the assumption that arr = asarray(original)
",function,"('(arr, original)',)",scipy,1.1.0,scipy.linalg.decomp_qr._datacopied,linalg.decomp_qr,_datacopied,"Python Library Documentation: function _datacopied in module scipy.linalg.misc

_datacopied(arr, original)
    Strict check for `arr` not sharing any data with `original`,
    under the assumption that arr = asarray(original)
",function,"('arr', 'original')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(arr, original)',)"
scipy,1.1.0,scipy.linalg.decomp_qr.get_lapack_funcs,linalg.decomp_qr,get_lapack_funcs,"Python Library Documentation: function get_lapack_funcs in module scipy.linalg.lapack

get_lapack_funcs(names, arrays=(), dtype=None)
    Return available LAPACK function objects from names.
    
    Arrays are used to determine the optimal prefix of LAPACK routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of LAPACK functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of LAPACK
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In LAPACK, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively, and
    are stored in attribute ``typecode`` of the returned functions.
    
    Examples
    --------
    Suppose we would like to use '?lange' routine which computes the selected
    norm of an array. We pass our array in order to get the correct 'lange'
    flavor.
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_lange = LA.get_lapack_funcs('lange', (a,))
    >>> x_lange.typecode
    'd'
    >>> x_lange = LA.get_lapack_funcs('lange',(a*1j,))
    >>> x_lange.typecode
    'z'
    
    Several LAPACK routines work best when its internal WORK array has
    the optimal size (big enough for fast computation and small enough to
    avoid waste of memory). This size is determined also by a dedicated query
    to the function which is often wrapped as a standalone function and
    commonly denoted as ``###_lwork``. Below is an example for ``?sysv``
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(1000,1000)
    >>> b = np.random.rand(1000,1)*1j
    >>> # We pick up zsysv and zsysv_lwork due to b array
    ... xsysv, xlwork = LA.get_lapack_funcs(('sysv', 'sysv_lwork'), (a, b))
    >>> opt_lwork, _ = xlwork(a.shape[0])  # returns a complex for 'z' prefix
    >>> udut, ipiv, x, info = xsysv(a, b, lwork=int(opt_lwork.real))
",function,"('(names, arrays=(), dtype=None)',)",scipy,1.1.0,scipy.linalg.decomp_qr.get_lapack_funcs,linalg.decomp_qr,get_lapack_funcs,"Python Library Documentation: function get_lapack_funcs in module scipy.linalg.lapack

get_lapack_funcs(names, arrays=(), dtype=None)
    Return available LAPACK function objects from names.
    
    Arrays are used to determine the optimal prefix of LAPACK routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of LAPACK functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of LAPACK
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In LAPACK, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively, and
    are stored in attribute ``typecode`` of the returned functions.
    
    Examples
    --------
    Suppose we would like to use '?lange' routine which computes the selected
    norm of an array. We pass our array in order to get the correct 'lange'
    flavor.
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_lange = LA.get_lapack_funcs('lange', (a,))
    >>> x_lange.typecode
    'd'
    >>> x_lange = LA.get_lapack_funcs('lange',(a*1j,))
    >>> x_lange.typecode
    'z'
    
    Several LAPACK routines work best when its internal WORK array has
    the optimal size (big enough for fast computation and small enough to
    avoid waste of memory). This size is determined also by a dedicated query
    to the function which is often wrapped as a standalone function and
    commonly denoted as ``###_lwork``. Below is an example for ``?sysv``
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(1000,1000)
    >>> b = np.random.rand(1000,1)*1j
    >>> # We pick up zsysv and zsysv_lwork due to b array
    ... xsysv, xlwork = LA.get_lapack_funcs(('sysv', 'sysv_lwork'), (a, b))
    >>> opt_lwork, _ = xlwork(a.shape[0])  # returns a complex for 'z' prefix
    >>> udut, ipiv, x, info = xsysv(a, b, lwork=int(opt_lwork.real))
",function,"('names', 'arrays', 'dtype')","(nan, (), None)","(nan, 'tuple', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(names, arrays=(), dtype=None)',)"
scipy,1.1.0,scipy.linalg.decomp_qr.qr,linalg.decomp_qr,qr,"Python Library Documentation: function qr in module scipy.linalg.decomp_qr

qr(a, overwrite_a=False, lwork=None, mode='full', pivoting=False, check_finite=True)
    Compute QR decomposition of a matrix.
    
    Calculate the decomposition ``A = Q R`` where Q is unitary/orthogonal
    and R upper triangular.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to be decomposed
    overwrite_a : bool, optional
        Whether data in a is overwritten (may improve performance)
    lwork : int, optional
        Work array size, lwork >= a.shape[1]. If None or -1, an optimal size
        is computed.
    mode : {'full', 'r', 'economic', 'raw'}, optional
        Determines what information is to be returned: either both Q and R
        ('full', default), only R ('r') or both Q and R but computed in
        economy-size ('economic', see Notes). The final option 'raw'
        (added in Scipy 0.11) makes the function return two matrices
        (Q, TAU) in the internal format used by LAPACK.
    pivoting : bool, optional
        Whether or not factorization should include pivoting for rank-revealing
        qr decomposition. If pivoting, compute the decomposition
        ``A P = Q R`` as above, but where P is chosen such that the diagonal
        of R is non-increasing.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    Q : float or complex ndarray
        Of shape (M, M), or (M, K) for ``mode='economic'``.  Not returned
        if ``mode='r'``.
    R : float or complex ndarray
        Of shape (M, N), or (K, N) for ``mode='economic'``.  ``K = min(M, N)``.
    P : int ndarray
        Of shape (N,) for ``pivoting=True``. Not returned if
        ``pivoting=False``.
    
    Raises
    ------
    LinAlgError
        Raised if decomposition fails
    
    Notes
    -----
    This is an interface to the LAPACK routines dgeqrf, zgeqrf,
    dorgqr, zungqr, dgeqp3, and zgeqp3.
    
    If ``mode=economic``, the shapes of Q and R are (M, K) and (K, N) instead
    of (M,M) and (M,N), with ``K=min(M,N)``.
    
    Examples
    --------
    >>> from scipy import random, linalg, dot, diag, all, allclose
    >>> a = random.randn(9, 6)
    
    >>> q, r = linalg.qr(a)
    >>> allclose(a, np.dot(q, r))
    True
    >>> q.shape, r.shape
    ((9, 9), (9, 6))
    
    >>> r2 = linalg.qr(a, mode='r')
    >>> allclose(r, r2)
    True
    
    >>> q3, r3 = linalg.qr(a, mode='economic')
    >>> q3.shape, r3.shape
    ((9, 6), (6, 6))
    
    >>> q4, r4, p4 = linalg.qr(a, pivoting=True)
    >>> d = abs(diag(r4))
    >>> all(d[1:] <= d[:-1])
    True
    >>> allclose(a[:, p4], dot(q4, r4))
    True
    >>> q4.shape, r4.shape, p4.shape
    ((9, 9), (9, 6), (6,))
    
    >>> q5, r5, p5 = linalg.qr(a, mode='economic', pivoting=True)
    >>> q5.shape, r5.shape, p5.shape
    ((9, 6), (6, 6), (6,))
",function,"(""(a, overwrite_a=False, lwork=None, mode='full', pivoting=False, check_finite=True)"",)",scipy,1.1.0,scipy.linalg.decomp_qr.qr,linalg.decomp_qr,qr,"Python Library Documentation: function qr in module scipy.linalg.decomp_qr

qr(a, overwrite_a=False, lwork=None, mode='full', pivoting=False, check_finite=True)
    Compute QR decomposition of a matrix.
    
    Calculate the decomposition ``A = Q R`` where Q is unitary/orthogonal
    and R upper triangular.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to be decomposed
    overwrite_a : bool, optional
        Whether data in a is overwritten (may improve performance)
    lwork : int, optional
        Work array size, lwork >= a.shape[1]. If None or -1, an optimal size
        is computed.
    mode : {'full', 'r', 'economic', 'raw'}, optional
        Determines what information is to be returned: either both Q and R
        ('full', default), only R ('r') or both Q and R but computed in
        economy-size ('economic', see Notes). The final option 'raw'
        (added in Scipy 0.11) makes the function return two matrices
        (Q, TAU) in the internal format used by LAPACK.
    pivoting : bool, optional
        Whether or not factorization should include pivoting for rank-revealing
        qr decomposition. If pivoting, compute the decomposition
        ``A P = Q R`` as above, but where P is chosen such that the diagonal
        of R is non-increasing.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    Q : float or complex ndarray
        Of shape (M, M), or (M, K) for ``mode='economic'``.  Not returned
        if ``mode='r'``.
    R : float or complex ndarray
        Of shape (M, N), or (K, N) for ``mode='economic'``.  ``K = min(M, N)``.
    P : int ndarray
        Of shape (N,) for ``pivoting=True``. Not returned if
        ``pivoting=False``.
    
    Raises
    ------
    LinAlgError
        Raised if decomposition fails
    
    Notes
    -----
    This is an interface to the LAPACK routines dgeqrf, zgeqrf,
    dorgqr, zungqr, dgeqp3, and zgeqp3.
    
    If ``mode=economic``, the shapes of Q and R are (M, K) and (K, N) instead
    of (M,M) and (M,N), with ``K=min(M,N)``.
    
    Examples
    --------
    >>> from scipy import random, linalg, dot, diag, all, allclose
    >>> a = random.randn(9, 6)
    
    >>> q, r = linalg.qr(a)
    >>> allclose(a, np.dot(q, r))
    True
    >>> q.shape, r.shape
    ((9, 9), (9, 6))
    
    >>> r2 = linalg.qr(a, mode='r')
    >>> allclose(r, r2)
    True
    
    >>> q3, r3 = linalg.qr(a, mode='economic')
    >>> q3.shape, r3.shape
    ((9, 6), (6, 6))
    
    >>> q4, r4, p4 = linalg.qr(a, pivoting=True)
    >>> d = abs(diag(r4))
    >>> all(d[1:] <= d[:-1])
    True
    >>> allclose(a[:, p4], dot(q4, r4))
    True
    >>> q4.shape, r4.shape, p4.shape
    ((9, 9), (9, 6), (6,))
    
    >>> q5, r5, p5 = linalg.qr(a, mode='economic', pivoting=True)
    >>> q5.shape, r5.shape, p5.shape
    ((9, 6), (6, 6), (6,))
",function,"('a', 'overwrite_a', 'lwork', 'mode', 'pivoting', 'check_finite')","(nan, False, None, 'full', False, True)","(nan, 'bool', 'NoneType', 'str', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a, overwrite_a=False, lwork=None, mode='full', pivoting=False, check_finite=True)"",)"
scipy,1.1.0,scipy.linalg.decomp_qr.qr_multiply,linalg.decomp_qr,qr_multiply,"Python Library Documentation: function qr_multiply in module scipy.linalg.decomp_qr

qr_multiply(a, c, mode='right', pivoting=False, conjugate=False, overwrite_a=False, overwrite_c=False)
    Calculate the QR decomposition and multiply Q with a matrix.
    
    Calculate the decomposition ``A = Q R`` where Q is unitary/orthogonal
    and R upper triangular. Multiply Q with a vector or a matrix c.
    
    Parameters
    ----------
    a : (M, N), array_like
        Input array
    c : array_like
        Input array to be multiplied by ``q``.
    mode : {'left', 'right'}, optional
        ``Q @ c`` is returned if mode is 'left', ``c @ Q`` is returned if
        mode is 'right'.
        The shape of c must be appropriate for the matrix multiplications,
        if mode is 'left', ``min(a.shape) == c.shape[0]``,
        if mode is 'right', ``a.shape[0] == c.shape[1]``.
    pivoting : bool, optional
        Whether or not factorization should include pivoting for rank-revealing
        qr decomposition, see the documentation of qr.
    conjugate : bool, optional
        Whether Q should be complex-conjugated. This might be faster
        than explicit conjugation.
    overwrite_a : bool, optional
        Whether data in a is overwritten (may improve performance)
    overwrite_c : bool, optional
        Whether data in c is overwritten (may improve performance).
        If this is used, c must be big enough to keep the result,
        i.e. ``c.shape[0]`` = ``a.shape[0]`` if mode is 'left'.
    
    Returns
    -------
    CQ : ndarray
        The product of ``Q`` and ``c``.
    R : (K, N), ndarray
        R array of the resulting QR factorization where ``K = min(M, N)``.
    P : (N,) ndarray
        Integer pivot array. Only returned when ``pivoting=True``.
    
    Raises
    ------
    LinAlgError
        Raised if QR decomposition fails.
    
    Notes
    -----
    This is an interface to the LAPACK routines ``?GEQRF``, ``?ORMQR``,
    ``?UNMQR``, and ``?GEQP3``.
    
    .. versionadded:: 0.11.0
    
    Examples
    --------
    >>> from scipy.linalg import qr_multiply, qr
    >>> A = np.array([[1, 3, 3], [2, 3, 2], [2, 3, 3], [1, 3, 2]])
    >>> qc, r1, piv1 = qr_multiply(A, 2*np.eye(4), pivoting=1)
    >>> qc
    array([[-1.,  1., -1.],
           [-1., -1.,  1.],
           [-1., -1., -1.],
           [-1.,  1.,  1.]])
    >>> r1
    array([[-6., -3., -5.            ],
           [ 0., -1., -1.11022302e-16],
           [ 0.,  0., -1.            ]])
    >>> piv1
    array([1, 0, 2], dtype=int32)
    >>> q2, r2, piv2 = qr(A, mode='economic', pivoting=1)
    >>> np.allclose(2*q2 - qc, np.zeros((4, 3)))
    True
",function,"(""(a, c, mode='right', pivoting=False, conjugate=False, overwrite_a=False, overwrite_c=False)"",)",scipy,1.1.0,scipy.linalg.decomp_qr.qr_multiply,linalg.decomp_qr,qr_multiply,"Python Library Documentation: function qr_multiply in module scipy.linalg.decomp_qr

qr_multiply(a, c, mode='right', pivoting=False, conjugate=False, overwrite_a=False, overwrite_c=False)
    Calculate the QR decomposition and multiply Q with a matrix.
    
    Calculate the decomposition ``A = Q R`` where Q is unitary/orthogonal
    and R upper triangular. Multiply Q with a vector or a matrix c.
    
    Parameters
    ----------
    a : (M, N), array_like
        Input array
    c : array_like
        Input array to be multiplied by ``q``.
    mode : {'left', 'right'}, optional
        ``Q @ c`` is returned if mode is 'left', ``c @ Q`` is returned if
        mode is 'right'.
        The shape of c must be appropriate for the matrix multiplications,
        if mode is 'left', ``min(a.shape) == c.shape[0]``,
        if mode is 'right', ``a.shape[0] == c.shape[1]``.
    pivoting : bool, optional
        Whether or not factorization should include pivoting for rank-revealing
        qr decomposition, see the documentation of qr.
    conjugate : bool, optional
        Whether Q should be complex-conjugated. This might be faster
        than explicit conjugation.
    overwrite_a : bool, optional
        Whether data in a is overwritten (may improve performance)
    overwrite_c : bool, optional
        Whether data in c is overwritten (may improve performance).
        If this is used, c must be big enough to keep the result,
        i.e. ``c.shape[0]`` = ``a.shape[0]`` if mode is 'left'.
    
    Returns
    -------
    CQ : ndarray
        The product of ``Q`` and ``c``.
    R : (K, N), ndarray
        R array of the resulting QR factorization where ``K = min(M, N)``.
    P : (N,) ndarray
        Integer pivot array. Only returned when ``pivoting=True``.
    
    Raises
    ------
    LinAlgError
        Raised if QR decomposition fails.
    
    Notes
    -----
    This is an interface to the LAPACK routines ``?GEQRF``, ``?ORMQR``,
    ``?UNMQR``, and ``?GEQP3``.
    
    .. versionadded:: 0.11.0
    
    Examples
    --------
    >>> from scipy.linalg import qr_multiply, qr
    >>> A = np.array([[1, 3, 3], [2, 3, 2], [2, 3, 3], [1, 3, 2]])
    >>> qc, r1, piv1 = qr_multiply(A, 2*np.eye(4), pivoting=1)
    >>> qc
    array([[-1.,  1., -1.],
           [-1., -1.,  1.],
           [-1., -1., -1.],
           [-1.,  1.,  1.]])
    >>> r1
    array([[-6., -3., -5.            ],
           [ 0., -1., -1.11022302e-16],
           [ 0.,  0., -1.            ]])
    >>> piv1
    array([1, 0, 2], dtype=int32)
    >>> q2, r2, piv2 = qr(A, mode='economic', pivoting=1)
    >>> np.allclose(2*q2 - qc, np.zeros((4, 3)))
    True
",function,"('a', 'c', 'mode', 'pivoting', 'conjugate', 'overwrite_a', 'overwrite_c')","(nan, nan, 'right', False, False, False, False)","(nan, nan, 'str', 'bool', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a, c, mode='right', pivoting=False, conjugate=False, overwrite_a=False, overwrite_c=False)"",)"
scipy,1.1.0,scipy.linalg.decomp_qr.rq,linalg.decomp_qr,rq,"Python Library Documentation: function rq in module scipy.linalg.decomp_qr

rq(a, overwrite_a=False, lwork=None, mode='full', check_finite=True)
    Compute RQ decomposition of a matrix.
    
    Calculate the decomposition ``A = R Q`` where Q is unitary/orthogonal
    and R upper triangular.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to be decomposed
    overwrite_a : bool, optional
        Whether data in a is overwritten (may improve performance)
    lwork : int, optional
        Work array size, lwork >= a.shape[1]. If None or -1, an optimal size
        is computed.
    mode : {'full', 'r', 'economic'}, optional
        Determines what information is to be returned: either both Q and R
        ('full', default), only R ('r') or both Q and R but computed in
        economy-size ('economic', see Notes).
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    R : float or complex ndarray
        Of shape (M, N) or (M, K) for ``mode='economic'``.  ``K = min(M, N)``.
    Q : float or complex ndarray
        Of shape (N, N) or (K, N) for ``mode='economic'``.  Not returned
        if ``mode='r'``.
    
    Raises
    ------
    LinAlgError
        If decomposition fails.
    
    Notes
    -----
    This is an interface to the LAPACK routines sgerqf, dgerqf, cgerqf, zgerqf,
    sorgrq, dorgrq, cungrq and zungrq.
    
    If ``mode=economic``, the shapes of Q and R are (K, N) and (M, K) instead
    of (N,N) and (M,N), with ``K=min(M,N)``.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.random.randn(6, 9)
    >>> r, q = linalg.rq(a)
    >>> np.allclose(a, r @ q)
    True
    >>> r.shape, q.shape
    ((6, 9), (9, 9))
    >>> r2 = linalg.rq(a, mode='r')
    >>> np.allclose(r, r2)
    True
    >>> r3, q3 = linalg.rq(a, mode='economic')
    >>> r3.shape, q3.shape
    ((6, 6), (6, 9))
",function,"(""(a, overwrite_a=False, lwork=None, mode='full', check_finite=True)"",)",scipy,1.1.0,scipy.linalg.decomp_qr.rq,linalg.decomp_qr,rq,"Python Library Documentation: function rq in module scipy.linalg.decomp_qr

rq(a, overwrite_a=False, lwork=None, mode='full', check_finite=True)
    Compute RQ decomposition of a matrix.
    
    Calculate the decomposition ``A = R Q`` where Q is unitary/orthogonal
    and R upper triangular.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to be decomposed
    overwrite_a : bool, optional
        Whether data in a is overwritten (may improve performance)
    lwork : int, optional
        Work array size, lwork >= a.shape[1]. If None or -1, an optimal size
        is computed.
    mode : {'full', 'r', 'economic'}, optional
        Determines what information is to be returned: either both Q and R
        ('full', default), only R ('r') or both Q and R but computed in
        economy-size ('economic', see Notes).
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    R : float or complex ndarray
        Of shape (M, N) or (M, K) for ``mode='economic'``.  ``K = min(M, N)``.
    Q : float or complex ndarray
        Of shape (N, N) or (K, N) for ``mode='economic'``.  Not returned
        if ``mode='r'``.
    
    Raises
    ------
    LinAlgError
        If decomposition fails.
    
    Notes
    -----
    This is an interface to the LAPACK routines sgerqf, dgerqf, cgerqf, zgerqf,
    sorgrq, dorgrq, cungrq and zungrq.
    
    If ``mode=economic``, the shapes of Q and R are (K, N) and (M, K) instead
    of (N,N) and (M,N), with ``K=min(M,N)``.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.random.randn(6, 9)
    >>> r, q = linalg.rq(a)
    >>> np.allclose(a, r @ q)
    True
    >>> r.shape, q.shape
    ((6, 9), (9, 9))
    >>> r2 = linalg.rq(a, mode='r')
    >>> np.allclose(r, r2)
    True
    >>> r3, q3 = linalg.rq(a, mode='economic')
    >>> r3.shape, q3.shape
    ((6, 6), (6, 9))
",function,"('a', 'overwrite_a', 'lwork', 'mode', 'check_finite')","(nan, False, None, 'full', True)","(nan, 'bool', 'NoneType', 'str', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a, overwrite_a=False, lwork=None, mode='full', check_finite=True)"",)"
scipy,1.1.0,scipy.linalg.decomp_qr.safecall,linalg.decomp_qr,safecall,"Python Library Documentation: function safecall in module scipy.linalg.decomp_qr

safecall(f, name, *args, **kwargs)
    Call a LAPACK routine, determining lwork automatically and handling
    error return values
",function,"('(f, name, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg.decomp_qr.safecall,linalg.decomp_qr,safecall,"Python Library Documentation: function safecall in module scipy.linalg.decomp_qr

safecall(f, name, *args, **kwargs)
    Call a LAPACK routine, determining lwork automatically and handling
    error return values
",function,"('f', 'name')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(f, name, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg.decomp_schur.LinAlgError,linalg.decomp_schur,LinAlgError,"Python Library Documentation: class LinAlgError in module numpy.linalg.linalg

class LinAlgError(builtins.Exception)
 |  Generic Python-exception-derived object raised by linalg functions.
 |  
 |  General purpose exception class, derived from Python's exception.Exception
 |  class, programmatically raised in linalg functions when a Linear
 |  Algebra-related condition would prevent further correct execution of the
 |  function.
 |  
 |  Parameters
 |  ----------
 |  None
 |  
 |  Examples
 |  --------
 |  >>> from numpy import linalg as LA
 |  >>> LA.inv(np.zeros((2,2)))
 |  Traceback (most recent call last):
 |    File ""<stdin>"", line 1, in <module>
 |    File ""...linalg.py"", line 350,
 |      in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
 |    File ""...linalg.py"", line 249,
 |      in solve
 |      raise LinAlgError('Singular matrix')
 |  numpy.linalg.LinAlgError: Singular matrix
 |  
 |  Method resolution order:
 |      LinAlgError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg.decomp_schur.LinAlgError,linalg.decomp_schur,LinAlgError,"Python Library Documentation: class LinAlgError in module numpy.linalg.linalg

class LinAlgError(builtins.Exception)
 |  Generic Python-exception-derived object raised by linalg functions.
 |  
 |  General purpose exception class, derived from Python's exception.Exception
 |  class, programmatically raised in linalg functions when a Linear
 |  Algebra-related condition would prevent further correct execution of the
 |  function.
 |  
 |  Parameters
 |  ----------
 |  None
 |  
 |  Examples
 |  --------
 |  >>> from numpy import linalg as LA
 |  >>> LA.inv(np.zeros((2,2)))
 |  Traceback (most recent call last):
 |    File ""<stdin>"", line 1, in <module>
 |    File ""...linalg.py"", line 350,
 |      in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
 |    File ""...linalg.py"", line 249,
 |      in solve
 |      raise LinAlgError('Singular matrix')
 |  numpy.linalg.LinAlgError: Singular matrix
 |  
 |  Method resolution order:
 |      LinAlgError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg.decomp_schur._castCopy,linalg.decomp_schur,_castCopy,"Python Library Documentation: function _castCopy in module scipy.linalg.decomp_schur

_castCopy(type, *arrays)
",function,"('(type, *arrays)',)",scipy,1.1.0,scipy.linalg.decomp_schur._castCopy,linalg.decomp_schur,_castCopy,"Python Library Documentation: function _castCopy in module scipy.linalg.decomp_schur

_castCopy(type, *arrays)
",function,"('type',)","(nan,)","(nan,)","('arg_info',)","('(type, *arrays)',)"
scipy,1.1.0,scipy.linalg.decomp_schur._commonType,linalg.decomp_schur,_commonType,"Python Library Documentation: function _commonType in module scipy.linalg.decomp_schur

_commonType(*arrays)
",function,"('(*arrays)',)",scipy,1.1.0,scipy.linalg.decomp_schur._commonType,linalg.decomp_schur,_commonType,"Python Library Documentation: function _commonType in module scipy.linalg.decomp_schur

_commonType(*arrays)
",function,(),(),(),(),"('(*arrays)',)"
scipy,1.1.0,scipy.linalg.decomp_schur._datacopied,linalg.decomp_schur,_datacopied,"Python Library Documentation: function _datacopied in module scipy.linalg.misc

_datacopied(arr, original)
    Strict check for `arr` not sharing any data with `original`,
    under the assumption that arr = asarray(original)
",function,"('(arr, original)',)",scipy,1.1.0,scipy.linalg.decomp_schur._datacopied,linalg.decomp_schur,_datacopied,"Python Library Documentation: function _datacopied in module scipy.linalg.misc

_datacopied(arr, original)
    Strict check for `arr` not sharing any data with `original`,
    under the assumption that arr = asarray(original)
",function,"('arr', 'original')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(arr, original)',)"
scipy,1.1.0,scipy.linalg.decomp_schur.asarray,linalg.decomp_schur,asarray,"Python Library Documentation: function asarray in module numpy.core.numeric

asarray(a, dtype=None, order=None)
    Convert the input to an array.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
        Whether to use row-major (C-style) or
        column-major (Fortran-style) memory representation.
        Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray with matching dtype and order.  If `a` is a
        subclass of ndarray, a base class ndarray is returned.
    
    See Also
    --------
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    asarray_chkfinite : Similar function which checks input for NaNs and Infs.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array:
    
    >>> a = [1, 2]
    >>> np.asarray(a)
    array([1, 2])
    
    Existing arrays are not copied:
    
    >>> a = np.array([1, 2])
    >>> np.asarray(a) is a
    True
    
    If `dtype` is set, array is copied only if dtype does not match:
    
    >>> a = np.array([1, 2], dtype=np.float32)
    >>> np.asarray(a, dtype=np.float32) is a
    True
    >>> np.asarray(a, dtype=np.float64) is a
    False
    
    Contrary to `asanyarray`, ndarray subclasses are not passed through:
    
    >>> issubclass(np.matrix, np.ndarray)
    True
    >>> a = np.matrix([[1, 2]])
    >>> np.asarray(a) is a
    False
    >>> np.asanyarray(a) is a
    True
",function,"('(a, dtype=None, order=None)',)",scipy,1.1.0,scipy.linalg.decomp_schur.asarray,linalg.decomp_schur,asarray,"Python Library Documentation: function asarray in module numpy.core.numeric

asarray(a, dtype=None, order=None)
    Convert the input to an array.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
        Whether to use row-major (C-style) or
        column-major (Fortran-style) memory representation.
        Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray with matching dtype and order.  If `a` is a
        subclass of ndarray, a base class ndarray is returned.
    
    See Also
    --------
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    asarray_chkfinite : Similar function which checks input for NaNs and Infs.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array:
    
    >>> a = [1, 2]
    >>> np.asarray(a)
    array([1, 2])
    
    Existing arrays are not copied:
    
    >>> a = np.array([1, 2])
    >>> np.asarray(a) is a
    True
    
    If `dtype` is set, array is copied only if dtype does not match:
    
    >>> a = np.array([1, 2], dtype=np.float32)
    >>> np.asarray(a, dtype=np.float32) is a
    True
    >>> np.asarray(a, dtype=np.float64) is a
    False
    
    Contrary to `asanyarray`, ndarray subclasses are not passed through:
    
    >>> issubclass(np.matrix, np.ndarray)
    True
    >>> a = np.matrix([[1, 2]])
    >>> np.asarray(a) is a
    False
    >>> np.asanyarray(a) is a
    True
",function,"('a', 'dtype', 'order')","(nan, None, None)","(nan, 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(a, dtype=None, order=None)',)"
scipy,1.1.0,scipy.linalg.decomp_schur.asarray_chkfinite,linalg.decomp_schur,asarray_chkfinite,"Python Library Documentation: function asarray_chkfinite in module numpy.lib.function_base

asarray_chkfinite(a, dtype=None, order=None)
    Convert the input to an array, checking for NaNs or Infs.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.  Success requires no NaNs or Infs.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
         Whether to use row-major (C-style) or
         column-major (Fortran-style) memory representation.
         Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray.  If `a` is a subclass of ndarray, a base
        class ndarray is returned.
    
    Raises
    ------
    ValueError
        Raises ValueError if `a` contains NaN (Not a Number) or Inf (Infinity).
    
    See Also
    --------
    asarray : Create and array.
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array.  If all elements are finite
    ``asarray_chkfinite`` is identical to ``asarray``.
    
    >>> a = [1, 2]
    >>> np.asarray_chkfinite(a, dtype=float)
    array([1., 2.])
    
    Raises ValueError if array_like contains Nans or Infs.
    
    >>> a = [1, 2, np.inf]
    >>> try:
    ...     np.asarray_chkfinite(a)
    ... except ValueError:
    ...     print('ValueError')
    ...
    ValueError
",function,"('(a, dtype=None, order=None)',)",scipy,1.1.0,scipy.linalg.decomp_schur.asarray_chkfinite,linalg.decomp_schur,asarray_chkfinite,"Python Library Documentation: function asarray_chkfinite in module numpy.lib.function_base

asarray_chkfinite(a, dtype=None, order=None)
    Convert the input to an array, checking for NaNs or Infs.
    
    Parameters
    ----------
    a : array_like
        Input data, in any form that can be converted to an array.  This
        includes lists, lists of tuples, tuples, tuples of tuples, tuples
        of lists and ndarrays.  Success requires no NaNs or Infs.
    dtype : data-type, optional
        By default, the data-type is inferred from the input data.
    order : {'C', 'F'}, optional
         Whether to use row-major (C-style) or
         column-major (Fortran-style) memory representation.
         Defaults to 'C'.
    
    Returns
    -------
    out : ndarray
        Array interpretation of `a`.  No copy is performed if the input
        is already an ndarray.  If `a` is a subclass of ndarray, a base
        class ndarray is returned.
    
    Raises
    ------
    ValueError
        Raises ValueError if `a` contains NaN (Not a Number) or Inf (Infinity).
    
    See Also
    --------
    asarray : Create and array.
    asanyarray : Similar function which passes through subclasses.
    ascontiguousarray : Convert input to a contiguous array.
    asfarray : Convert input to a floating point ndarray.
    asfortranarray : Convert input to an ndarray with column-major
                     memory order.
    fromiter : Create an array from an iterator.
    fromfunction : Construct an array by executing a function on grid
                   positions.
    
    Examples
    --------
    Convert a list into an array.  If all elements are finite
    ``asarray_chkfinite`` is identical to ``asarray``.
    
    >>> a = [1, 2]
    >>> np.asarray_chkfinite(a, dtype=float)
    array([1., 2.])
    
    Raises ValueError if array_like contains Nans or Infs.
    
    >>> a = [1, 2, np.inf]
    >>> try:
    ...     np.asarray_chkfinite(a)
    ... except ValueError:
    ...     print('ValueError')
    ...
    ValueError
",function,"('a', 'dtype', 'order')","(nan, None, None)","(nan, 'NoneType', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(a, dtype=None, order=None)',)"
scipy,1.1.0,scipy.linalg.decomp_schur.callable,linalg.decomp_schur,callable,"Python Library Documentation: function callable in module scipy._lib.six

callable(obj)
",function,"('(obj)',)",scipy,1.1.0,scipy.linalg.decomp_schur.callable,linalg.decomp_schur,callable,"Python Library Documentation: function callable in module scipy._lib.six

callable(obj)
",function,"('obj',)","(nan,)","(nan,)","('arg_info',)","('(obj)',)"
scipy,1.1.0,scipy.linalg.decomp_schur.eigvals,linalg.decomp_schur,eigvals,"Python Library Documentation: function eigvals in module scipy.linalg.decomp

eigvals(a, b=None, overwrite_a=False, check_finite=True, homogeneous_eigvals=False)
    Compute eigenvalues from an ordinary or generalized eigenvalue problem.
    
    Find eigenvalues of a general matrix::
    
        a   vr[:,i] = w[i]        b   vr[:,i]
    
    Parameters
    ----------
    a : (M, M) array_like
        A complex or real matrix whose eigenvalues and eigenvectors
        will be computed.
    b : (M, M) array_like, optional
        Right-hand side matrix in a generalized eigenvalue problem.
        If omitted, identity matrix is assumed.
    overwrite_a : bool, optional
        Whether to overwrite data in a (may improve performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities
        or NaNs.
    homogeneous_eigvals : bool, optional
        If True, return the eigenvalues in homogeneous coordinates.
        In this case ``w`` is a (2, M) array so that::
    
            w[1,i] a vr[:,i] = w[0,i] b vr[:,i]
    
        Default is False.
    
    Returns
    -------
    w : (M,) or (2, M) double or complex ndarray
        The eigenvalues, each repeated according to its multiplicity
        but not in any specific order. The shape is (M,) unless
        ``homogeneous_eigvals=True``.
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge
    
    See Also
    --------
    eig : eigenvalues and right eigenvectors of general arrays.
    eigvalsh : eigenvalues of symmetric or Hermitian arrays
    eigvals_banded : eigenvalues for symmetric/Hermitian band matrices
    eigvalsh_tridiagonal : eigenvalues of symmetric/Hermitian tridiagonal
        matrices
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.array([[0., -1.], [1., 0.]])
    >>> linalg.eigvals(a)
    array([0.+1.j, 0.-1.j])
    
    >>> b = np.array([[0., 1.], [1., 1.]])
    >>> linalg.eigvals(a, b)
    array([ 1.+0.j, -1.+0.j])
    
    >>> a = np.array([[3., 0., 0.], [0., 8., 0.], [0., 0., 7.]])
    >>> linalg.eigvals(a, homogeneous_eigvals=True)
    array([[3.+0.j, 8.+0.j, 7.+0.j],
           [1.+0.j, 1.+0.j, 1.+0.j]])
",function,"('(a, b=None, overwrite_a=False, check_finite=True, homogeneous_eigvals=False)',)",scipy,1.1.0,scipy.linalg.decomp_schur.eigvals,linalg.decomp_schur,eigvals,"Python Library Documentation: function eigvals in module scipy.linalg.decomp

eigvals(a, b=None, overwrite_a=False, check_finite=True, homogeneous_eigvals=False)
    Compute eigenvalues from an ordinary or generalized eigenvalue problem.
    
    Find eigenvalues of a general matrix::
    
        a   vr[:,i] = w[i]        b   vr[:,i]
    
    Parameters
    ----------
    a : (M, M) array_like
        A complex or real matrix whose eigenvalues and eigenvectors
        will be computed.
    b : (M, M) array_like, optional
        Right-hand side matrix in a generalized eigenvalue problem.
        If omitted, identity matrix is assumed.
    overwrite_a : bool, optional
        Whether to overwrite data in a (may improve performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities
        or NaNs.
    homogeneous_eigvals : bool, optional
        If True, return the eigenvalues in homogeneous coordinates.
        In this case ``w`` is a (2, M) array so that::
    
            w[1,i] a vr[:,i] = w[0,i] b vr[:,i]
    
        Default is False.
    
    Returns
    -------
    w : (M,) or (2, M) double or complex ndarray
        The eigenvalues, each repeated according to its multiplicity
        but not in any specific order. The shape is (M,) unless
        ``homogeneous_eigvals=True``.
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge
    
    See Also
    --------
    eig : eigenvalues and right eigenvectors of general arrays.
    eigvalsh : eigenvalues of symmetric or Hermitian arrays
    eigvals_banded : eigenvalues for symmetric/Hermitian band matrices
    eigvalsh_tridiagonal : eigenvalues of symmetric/Hermitian tridiagonal
        matrices
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.array([[0., -1.], [1., 0.]])
    >>> linalg.eigvals(a)
    array([0.+1.j, 0.-1.j])
    
    >>> b = np.array([[0., 1.], [1., 1.]])
    >>> linalg.eigvals(a, b)
    array([ 1.+0.j, -1.+0.j])
    
    >>> a = np.array([[3., 0., 0.], [0., 8., 0.], [0., 0., 7.]])
    >>> linalg.eigvals(a, homogeneous_eigvals=True)
    array([[3.+0.j, 8.+0.j, 7.+0.j],
           [1.+0.j, 1.+0.j, 1.+0.j]])
",function,"('a', 'b', 'overwrite_a', 'check_finite', 'homogeneous_eigvals')","(nan, None, False, True, False)","(nan, 'NoneType', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, b=None, overwrite_a=False, check_finite=True, homogeneous_eigvals=False)',)"
scipy,1.1.0,scipy.linalg.decomp_schur.get_lapack_funcs,linalg.decomp_schur,get_lapack_funcs,"Python Library Documentation: function get_lapack_funcs in module scipy.linalg.lapack

get_lapack_funcs(names, arrays=(), dtype=None)
    Return available LAPACK function objects from names.
    
    Arrays are used to determine the optimal prefix of LAPACK routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of LAPACK functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of LAPACK
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In LAPACK, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively, and
    are stored in attribute ``typecode`` of the returned functions.
    
    Examples
    --------
    Suppose we would like to use '?lange' routine which computes the selected
    norm of an array. We pass our array in order to get the correct 'lange'
    flavor.
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_lange = LA.get_lapack_funcs('lange', (a,))
    >>> x_lange.typecode
    'd'
    >>> x_lange = LA.get_lapack_funcs('lange',(a*1j,))
    >>> x_lange.typecode
    'z'
    
    Several LAPACK routines work best when its internal WORK array has
    the optimal size (big enough for fast computation and small enough to
    avoid waste of memory). This size is determined also by a dedicated query
    to the function which is often wrapped as a standalone function and
    commonly denoted as ``###_lwork``. Below is an example for ``?sysv``
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(1000,1000)
    >>> b = np.random.rand(1000,1)*1j
    >>> # We pick up zsysv and zsysv_lwork due to b array
    ... xsysv, xlwork = LA.get_lapack_funcs(('sysv', 'sysv_lwork'), (a, b))
    >>> opt_lwork, _ = xlwork(a.shape[0])  # returns a complex for 'z' prefix
    >>> udut, ipiv, x, info = xsysv(a, b, lwork=int(opt_lwork.real))
",function,"('(names, arrays=(), dtype=None)',)",scipy,1.1.0,scipy.linalg.decomp_schur.get_lapack_funcs,linalg.decomp_schur,get_lapack_funcs,"Python Library Documentation: function get_lapack_funcs in module scipy.linalg.lapack

get_lapack_funcs(names, arrays=(), dtype=None)
    Return available LAPACK function objects from names.
    
    Arrays are used to determine the optimal prefix of LAPACK routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of LAPACK functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of LAPACK
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In LAPACK, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively, and
    are stored in attribute ``typecode`` of the returned functions.
    
    Examples
    --------
    Suppose we would like to use '?lange' routine which computes the selected
    norm of an array. We pass our array in order to get the correct 'lange'
    flavor.
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_lange = LA.get_lapack_funcs('lange', (a,))
    >>> x_lange.typecode
    'd'
    >>> x_lange = LA.get_lapack_funcs('lange',(a*1j,))
    >>> x_lange.typecode
    'z'
    
    Several LAPACK routines work best when its internal WORK array has
    the optimal size (big enough for fast computation and small enough to
    avoid waste of memory). This size is determined also by a dedicated query
    to the function which is often wrapped as a standalone function and
    commonly denoted as ``###_lwork``. Below is an example for ``?sysv``
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(1000,1000)
    >>> b = np.random.rand(1000,1)*1j
    >>> # We pick up zsysv and zsysv_lwork due to b array
    ... xsysv, xlwork = LA.get_lapack_funcs(('sysv', 'sysv_lwork'), (a, b))
    >>> opt_lwork, _ = xlwork(a.shape[0])  # returns a complex for 'z' prefix
    >>> udut, ipiv, x, info = xsysv(a, b, lwork=int(opt_lwork.real))
",function,"('names', 'arrays', 'dtype')","(nan, (), None)","(nan, 'tuple', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(names, arrays=(), dtype=None)',)"
scipy,1.1.0,scipy.linalg.decomp_schur.norm,linalg.decomp_schur,norm,"Python Library Documentation: function norm in module numpy.linalg.linalg

norm(x, ord=None, axis=None, keepdims=False)
    Matrix or vector norm.
    
    This function is able to return one of eight different matrix norms,
    or one of an infinite number of vector norms (described below), depending
    on the value of the ``ord`` parameter.
    
    Parameters
    ----------
    x : array_like
        Input array.  If `axis` is None, `x` must be 1-D or 2-D.
    ord : {non-zero int, inf, -inf, 'fro', 'nuc'}, optional
        Order of the norm (see table under ``Notes``). inf means numpy's
        `inf` object.
    axis : {int, 2-tuple of ints, None}, optional
        If `axis` is an integer, it specifies the axis of `x` along which to
        compute the vector norms.  If `axis` is a 2-tuple, it specifies the
        axes that hold 2-D matrices, and the matrix norms of these matrices
        are computed.  If `axis` is None then either a vector norm (when `x`
        is 1-D) or a matrix norm (when `x` is 2-D) is returned.
    keepdims : bool, optional
        If this is set to True, the axes which are normed over are left in the
        result as dimensions with size one.  With this option the result will
        broadcast correctly against the original `x`.
    
        .. versionadded:: 1.10.0
    
    Returns
    -------
    n : float or ndarray
        Norm of the matrix or vector(s).
    
    Notes
    -----
    For values of ``ord <= 0``, the result is, strictly speaking, not a
    mathematical 'norm', but it may still be useful for various numerical
    purposes.
    
    The following norms can be calculated:
    
    =====  ============================  ==========================
    ord    norm for matrices             norm for vectors
    =====  ============================  ==========================
    None   Frobenius norm                2-norm
    'fro'  Frobenius norm                --
    'nuc'  nuclear norm                  --
    inf    max(sum(abs(x), axis=1))      max(abs(x))
    -inf   min(sum(abs(x), axis=1))      min(abs(x))
    0      --                            sum(x != 0)
    1      max(sum(abs(x), axis=0))      as below
    -1     min(sum(abs(x), axis=0))      as below
    2      2-norm (largest sing. value)  as below
    -2     smallest singular value       as below
    other  --                            sum(abs(x)**ord)**(1./ord)
    =====  ============================  ==========================
    
    The Frobenius norm is given by [1]_:
    
        :math:`||A||_F = [\sum_{i,j} abs(a_{i,j})^2]^{1/2}`
    
    The nuclear norm is the sum of the singular values.
    
    References
    ----------
    .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*,
           Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15
    
    Examples
    --------
    >>> from numpy import linalg as LA
    >>> a = np.arange(9) - 4
    >>> a
    array([-4, -3, -2, -1,  0,  1,  2,  3,  4])
    >>> b = a.reshape((3, 3))
    >>> b
    array([[-4, -3, -2],
           [-1,  0,  1],
           [ 2,  3,  4]])
    
    >>> LA.norm(a)
    7.745966692414834
    >>> LA.norm(b)
    7.745966692414834
    >>> LA.norm(b, 'fro')
    7.745966692414834
    >>> LA.norm(a, np.inf)
    4.0
    >>> LA.norm(b, np.inf)
    9.0
    >>> LA.norm(a, -np.inf)
    0.0
    >>> LA.norm(b, -np.inf)
    2.0
    
    >>> LA.norm(a, 1)
    20.0
    >>> LA.norm(b, 1)
    7.0
    >>> LA.norm(a, -1)
    -4.6566128774142013e-010
    >>> LA.norm(b, -1)
    6.0
    >>> LA.norm(a, 2)
    7.745966692414834
    >>> LA.norm(b, 2)
    7.3484692283495345
    
    >>> LA.norm(a, -2)
    nan
    >>> LA.norm(b, -2)
    1.8570331885190563e-016
    >>> LA.norm(a, 3)
    5.8480354764257312
    >>> LA.norm(a, -3)
    nan
    
    Using the `axis` argument to compute vector norms:
    
    >>> c = np.array([[ 1, 2, 3],
    ...               [-1, 1, 4]])
    >>> LA.norm(c, axis=0)
    array([ 1.41421356,  2.23606798,  5.        ])
    >>> LA.norm(c, axis=1)
    array([ 3.74165739,  4.24264069])
    >>> LA.norm(c, ord=1, axis=1)
    array([ 6.,  6.])
    
    Using the `axis` argument to compute matrix norms:
    
    >>> m = np.arange(8).reshape(2,2,2)
    >>> LA.norm(m, axis=(1,2))
    array([  3.74165739,  11.22497216])
    >>> LA.norm(m[0, :, :]), LA.norm(m[1, :, :])
    (3.7416573867739413, 11.224972160321824)
",function,"('(x, ord=None, axis=None, keepdims=False)',)",scipy,1.1.0,scipy.linalg.decomp_schur.norm,linalg.decomp_schur,norm,"Python Library Documentation: function norm in module numpy.linalg.linalg

norm(x, ord=None, axis=None, keepdims=False)
    Matrix or vector norm.
    
    This function is able to return one of eight different matrix norms,
    or one of an infinite number of vector norms (described below), depending
    on the value of the ``ord`` parameter.
    
    Parameters
    ----------
    x : array_like
        Input array.  If `axis` is None, `x` must be 1-D or 2-D.
    ord : {non-zero int, inf, -inf, 'fro', 'nuc'}, optional
        Order of the norm (see table under ``Notes``). inf means numpy's
        `inf` object.
    axis : {int, 2-tuple of ints, None}, optional
        If `axis` is an integer, it specifies the axis of `x` along which to
        compute the vector norms.  If `axis` is a 2-tuple, it specifies the
        axes that hold 2-D matrices, and the matrix norms of these matrices
        are computed.  If `axis` is None then either a vector norm (when `x`
        is 1-D) or a matrix norm (when `x` is 2-D) is returned.
    keepdims : bool, optional
        If this is set to True, the axes which are normed over are left in the
        result as dimensions with size one.  With this option the result will
        broadcast correctly against the original `x`.
    
        .. versionadded:: 1.10.0
    
    Returns
    -------
    n : float or ndarray
        Norm of the matrix or vector(s).
    
    Notes
    -----
    For values of ``ord <= 0``, the result is, strictly speaking, not a
    mathematical 'norm', but it may still be useful for various numerical
    purposes.
    
    The following norms can be calculated:
    
    =====  ============================  ==========================
    ord    norm for matrices             norm for vectors
    =====  ============================  ==========================
    None   Frobenius norm                2-norm
    'fro'  Frobenius norm                --
    'nuc'  nuclear norm                  --
    inf    max(sum(abs(x), axis=1))      max(abs(x))
    -inf   min(sum(abs(x), axis=1))      min(abs(x))
    0      --                            sum(x != 0)
    1      max(sum(abs(x), axis=0))      as below
    -1     min(sum(abs(x), axis=0))      as below
    2      2-norm (largest sing. value)  as below
    -2     smallest singular value       as below
    other  --                            sum(abs(x)**ord)**(1./ord)
    =====  ============================  ==========================
    
    The Frobenius norm is given by [1]_:
    
        :math:`||A||_F = [\sum_{i,j} abs(a_{i,j})^2]^{1/2}`
    
    The nuclear norm is the sum of the singular values.
    
    References
    ----------
    .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*,
           Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15
    
    Examples
    --------
    >>> from numpy import linalg as LA
    >>> a = np.arange(9) - 4
    >>> a
    array([-4, -3, -2, -1,  0,  1,  2,  3,  4])
    >>> b = a.reshape((3, 3))
    >>> b
    array([[-4, -3, -2],
           [-1,  0,  1],
           [ 2,  3,  4]])
    
    >>> LA.norm(a)
    7.745966692414834
    >>> LA.norm(b)
    7.745966692414834
    >>> LA.norm(b, 'fro')
    7.745966692414834
    >>> LA.norm(a, np.inf)
    4.0
    >>> LA.norm(b, np.inf)
    9.0
    >>> LA.norm(a, -np.inf)
    0.0
    >>> LA.norm(b, -np.inf)
    2.0
    
    >>> LA.norm(a, 1)
    20.0
    >>> LA.norm(b, 1)
    7.0
    >>> LA.norm(a, -1)
    -4.6566128774142013e-010
    >>> LA.norm(b, -1)
    6.0
    >>> LA.norm(a, 2)
    7.745966692414834
    >>> LA.norm(b, 2)
    7.3484692283495345
    
    >>> LA.norm(a, -2)
    nan
    >>> LA.norm(b, -2)
    1.8570331885190563e-016
    >>> LA.norm(a, 3)
    5.8480354764257312
    >>> LA.norm(a, -3)
    nan
    
    Using the `axis` argument to compute vector norms:
    
    >>> c = np.array([[ 1, 2, 3],
    ...               [-1, 1, 4]])
    >>> LA.norm(c, axis=0)
    array([ 1.41421356,  2.23606798,  5.        ])
    >>> LA.norm(c, axis=1)
    array([ 3.74165739,  4.24264069])
    >>> LA.norm(c, ord=1, axis=1)
    array([ 6.,  6.])
    
    Using the `axis` argument to compute matrix norms:
    
    >>> m = np.arange(8).reshape(2,2,2)
    >>> LA.norm(m, axis=(1,2))
    array([  3.74165739,  11.22497216])
    >>> LA.norm(m[0, :, :]), LA.norm(m[1, :, :])
    (3.7416573867739413, 11.224972160321824)
",function,"('x', 'ord', 'axis', 'keepdims')","(nan, None, None, False)","(nan, 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, ord=None, axis=None, keepdims=False)',)"
scipy,1.1.0,scipy.linalg.decomp_schur.rsf2csf,linalg.decomp_schur,rsf2csf,"Python Library Documentation: function rsf2csf in module scipy.linalg.decomp_schur

rsf2csf(T, Z, check_finite=True)
    Convert real Schur form to complex Schur form.
    
    Convert a quasi-diagonal real-valued Schur form to the upper triangular
    complex-valued Schur form.
    
    Parameters
    ----------
    T : (M, M) array_like
        Real Schur form of the original array
    Z : (M, M) array_like
        Schur transformation matrix
    check_finite : bool, optional
        Whether to check that the input arrays contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    T : (M, M) ndarray
        Complex Schur form of the original array
    Z : (M, M) ndarray
        Schur transformation matrix corresponding to the complex form
    
    See Also
    --------
    schur : Schur decomposition of an array
    
    Examples
    --------
    >>> from scipy.linalg import schur, rsf2csf
    >>> A = np.array([[0, 2, 2], [0, 1, 2], [1, 0, 1]])
    >>> T, Z = schur(A)
    >>> T
    array([[ 2.65896708,  1.42440458, -1.92933439],
           [ 0.        , -0.32948354, -0.49063704],
           [ 0.        ,  1.31178921, -0.32948354]])
    >>> Z
    array([[0.72711591, -0.60156188, 0.33079564],
           [0.52839428, 0.79801892, 0.28976765],
           [0.43829436, 0.03590414, -0.89811411]])
    >>> T2 , Z2 = rsf2csf(T, Z)
    >>> T2
    array([[2.65896708+0.j, -1.64592781+0.743164187j, -1.21516887+1.00660462j],
           [0.+0.j , -0.32948354+8.02254558e-01j, -0.82115218-2.77555756e-17j],
           [0.+0.j , 0.+0.j, -0.32948354-0.802254558j]])
    >>> Z2
    array([[0.72711591+0.j,  0.28220393-0.31385693j,  0.51319638-0.17258824j],
           [0.52839428+0.j,  0.24720268+0.41635578j, -0.68079517-0.15118243j],
           [0.43829436+0.j, -0.76618703+0.01873251j, -0.03063006+0.46857912j]])
",function,"('(T, Z, check_finite=True)',)",scipy,1.1.0,scipy.linalg.decomp_schur.rsf2csf,linalg.decomp_schur,rsf2csf,"Python Library Documentation: function rsf2csf in module scipy.linalg.decomp_schur

rsf2csf(T, Z, check_finite=True)
    Convert real Schur form to complex Schur form.
    
    Convert a quasi-diagonal real-valued Schur form to the upper triangular
    complex-valued Schur form.
    
    Parameters
    ----------
    T : (M, M) array_like
        Real Schur form of the original array
    Z : (M, M) array_like
        Schur transformation matrix
    check_finite : bool, optional
        Whether to check that the input arrays contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    T : (M, M) ndarray
        Complex Schur form of the original array
    Z : (M, M) ndarray
        Schur transformation matrix corresponding to the complex form
    
    See Also
    --------
    schur : Schur decomposition of an array
    
    Examples
    --------
    >>> from scipy.linalg import schur, rsf2csf
    >>> A = np.array([[0, 2, 2], [0, 1, 2], [1, 0, 1]])
    >>> T, Z = schur(A)
    >>> T
    array([[ 2.65896708,  1.42440458, -1.92933439],
           [ 0.        , -0.32948354, -0.49063704],
           [ 0.        ,  1.31178921, -0.32948354]])
    >>> Z
    array([[0.72711591, -0.60156188, 0.33079564],
           [0.52839428, 0.79801892, 0.28976765],
           [0.43829436, 0.03590414, -0.89811411]])
    >>> T2 , Z2 = rsf2csf(T, Z)
    >>> T2
    array([[2.65896708+0.j, -1.64592781+0.743164187j, -1.21516887+1.00660462j],
           [0.+0.j , -0.32948354+8.02254558e-01j, -0.82115218-2.77555756e-17j],
           [0.+0.j , 0.+0.j, -0.32948354-0.802254558j]])
    >>> Z2
    array([[0.72711591+0.j,  0.28220393-0.31385693j,  0.51319638-0.17258824j],
           [0.52839428+0.j,  0.24720268+0.41635578j, -0.68079517-0.15118243j],
           [0.43829436+0.j, -0.76618703+0.01873251j, -0.03063006+0.46857912j]])
",function,"('T', 'Z', 'check_finite')","(nan, nan, True)","(nan, nan, 'bool')","('arg_info', 'arg_info', 'arg_info')","('(T, Z, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.decomp_schur.schur,linalg.decomp_schur,schur,"Python Library Documentation: function schur in module scipy.linalg.decomp_schur

schur(a, output='real', lwork=None, overwrite_a=False, sort=None, check_finite=True)
    Compute Schur decomposition of a matrix.
    
    The Schur decomposition is::
    
        A = Z T Z^H
    
    where Z is unitary and T is either upper-triangular, or for real
    Schur decomposition (output='real'), quasi-upper triangular.  In
    the quasi-triangular form, 2x2 blocks describing complex-valued
    eigenvalue pairs may extrude from the diagonal.
    
    Parameters
    ----------
    a : (M, M) array_like
        Matrix to decompose
    output : {'real', 'complex'}, optional
        Construct the real or complex Schur decomposition (for real matrices).
    lwork : int, optional
        Work array size. If None or -1, it is automatically computed.
    overwrite_a : bool, optional
        Whether to overwrite data in a (may improve performance).
    sort : {None, callable, 'lhp', 'rhp', 'iuc', 'ouc'}, optional
        Specifies whether the upper eigenvalues should be sorted.  A callable
        may be passed that, given a eigenvalue, returns a boolean denoting
        whether the eigenvalue should be sorted to the top-left (True).
        Alternatively, string parameters may be used::
    
            'lhp'   Left-hand plane (x.real < 0.0)
            'rhp'   Right-hand plane (x.real > 0.0)
            'iuc'   Inside the unit circle (x*x.conjugate() <= 1.0)
            'ouc'   Outside the unit circle (x*x.conjugate() > 1.0)
    
        Defaults to None (no sorting).
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    T : (M, M) ndarray
        Schur form of A. It is real-valued for the real Schur decomposition.
    Z : (M, M) ndarray
        An unitary Schur transformation matrix for A.
        It is real-valued for the real Schur decomposition.
    sdim : int
        If and only if sorting was requested, a third return value will
        contain the number of eigenvalues satisfying the sort condition.
    
    Raises
    ------
    LinAlgError
        Error raised under three conditions:
    
        1. The algorithm failed due to a failure of the QR algorithm to
           compute all eigenvalues
        2. If eigenvalue sorting was requested, the eigenvalues could not be
           reordered due to a failure to separate eigenvalues, usually because
           of poor conditioning
        3. If eigenvalue sorting was requested, roundoff errors caused the
           leading eigenvalues to no longer satisfy the sorting condition
    
    See also
    --------
    rsf2csf : Convert real Schur form to complex Schur form
    
    Examples
    --------
    >>> from scipy.linalg import schur, eigvals
    >>> A = np.array([[0, 2, 2], [0, 1, 2], [1, 0, 1]])
    >>> T, Z = schur(A)
    >>> T
    array([[ 2.65896708,  1.42440458, -1.92933439],
           [ 0.        , -0.32948354, -0.49063704],
           [ 0.        ,  1.31178921, -0.32948354]])
    >>> Z
    array([[0.72711591, -0.60156188, 0.33079564],
           [0.52839428, 0.79801892, 0.28976765],
           [0.43829436, 0.03590414, -0.89811411]])
    
    >>> T2, Z2 = schur(A, output='complex')
    >>> T2
    array([[ 2.65896708, -1.22839825+1.32378589j,  0.42590089+1.51937378j],
           [ 0.        , -0.32948354+0.80225456j, -0.59877807+0.56192146j],
           [ 0.        ,  0.                    , -0.32948354-0.80225456j]])
    >>> eigvals(T2)
    array([2.65896708, -0.32948354+0.80225456j, -0.32948354-0.80225456j])
    
    An arbitrary custom eig-sorting condition, having positive imaginary part, 
    which is satisfied by only one eigenvalue
    
    >>> T3, Z3, sdim = schur(A, output='complex', sort=lambda x: x.imag > 0)
    >>> sdim
    1
",function,"(""(a, output='real', lwork=None, overwrite_a=False, sort=None, check_finite=True)"",)",scipy,1.1.0,scipy.linalg.decomp_schur.schur,linalg.decomp_schur,schur,"Python Library Documentation: function schur in module scipy.linalg.decomp_schur

schur(a, output='real', lwork=None, overwrite_a=False, sort=None, check_finite=True)
    Compute Schur decomposition of a matrix.
    
    The Schur decomposition is::
    
        A = Z T Z^H
    
    where Z is unitary and T is either upper-triangular, or for real
    Schur decomposition (output='real'), quasi-upper triangular.  In
    the quasi-triangular form, 2x2 blocks describing complex-valued
    eigenvalue pairs may extrude from the diagonal.
    
    Parameters
    ----------
    a : (M, M) array_like
        Matrix to decompose
    output : {'real', 'complex'}, optional
        Construct the real or complex Schur decomposition (for real matrices).
    lwork : int, optional
        Work array size. If None or -1, it is automatically computed.
    overwrite_a : bool, optional
        Whether to overwrite data in a (may improve performance).
    sort : {None, callable, 'lhp', 'rhp', 'iuc', 'ouc'}, optional
        Specifies whether the upper eigenvalues should be sorted.  A callable
        may be passed that, given a eigenvalue, returns a boolean denoting
        whether the eigenvalue should be sorted to the top-left (True).
        Alternatively, string parameters may be used::
    
            'lhp'   Left-hand plane (x.real < 0.0)
            'rhp'   Right-hand plane (x.real > 0.0)
            'iuc'   Inside the unit circle (x*x.conjugate() <= 1.0)
            'ouc'   Outside the unit circle (x*x.conjugate() > 1.0)
    
        Defaults to None (no sorting).
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    T : (M, M) ndarray
        Schur form of A. It is real-valued for the real Schur decomposition.
    Z : (M, M) ndarray
        An unitary Schur transformation matrix for A.
        It is real-valued for the real Schur decomposition.
    sdim : int
        If and only if sorting was requested, a third return value will
        contain the number of eigenvalues satisfying the sort condition.
    
    Raises
    ------
    LinAlgError
        Error raised under three conditions:
    
        1. The algorithm failed due to a failure of the QR algorithm to
           compute all eigenvalues
        2. If eigenvalue sorting was requested, the eigenvalues could not be
           reordered due to a failure to separate eigenvalues, usually because
           of poor conditioning
        3. If eigenvalue sorting was requested, roundoff errors caused the
           leading eigenvalues to no longer satisfy the sorting condition
    
    See also
    --------
    rsf2csf : Convert real Schur form to complex Schur form
    
    Examples
    --------
    >>> from scipy.linalg import schur, eigvals
    >>> A = np.array([[0, 2, 2], [0, 1, 2], [1, 0, 1]])
    >>> T, Z = schur(A)
    >>> T
    array([[ 2.65896708,  1.42440458, -1.92933439],
           [ 0.        , -0.32948354, -0.49063704],
           [ 0.        ,  1.31178921, -0.32948354]])
    >>> Z
    array([[0.72711591, -0.60156188, 0.33079564],
           [0.52839428, 0.79801892, 0.28976765],
           [0.43829436, 0.03590414, -0.89811411]])
    
    >>> T2, Z2 = schur(A, output='complex')
    >>> T2
    array([[ 2.65896708, -1.22839825+1.32378589j,  0.42590089+1.51937378j],
           [ 0.        , -0.32948354+0.80225456j, -0.59877807+0.56192146j],
           [ 0.        ,  0.                    , -0.32948354-0.80225456j]])
    >>> eigvals(T2)
    array([2.65896708, -0.32948354+0.80225456j, -0.32948354-0.80225456j])
    
    An arbitrary custom eig-sorting condition, having positive imaginary part, 
    which is satisfied by only one eigenvalue
    
    >>> T3, Z3, sdim = schur(A, output='complex', sort=lambda x: x.imag > 0)
    >>> sdim
    1
",function,"('a', 'output', 'lwork', 'overwrite_a', 'sort', 'check_finite')","(nan, 'real', None, False, None, True)","(nan, 'str', 'NoneType', 'bool', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a, output='real', lwork=None, overwrite_a=False, sort=None, check_finite=True)"",)"
scipy,1.1.0,scipy.linalg.decomp_schur.single,linalg.decomp_schur,float32,"Python Library Documentation: class float32 in module numpy

class float32(floating)
 |  32-bit floating-point number. Character code 'f'. C float compatible.
 |  
 |  Method resolution order:
 |      float32
 |      floating
 |      inexact
 |      number
 |      generic
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from generic:
 |  
 |  __array__(...)
 |      sc.__array__(|type) return 0-dim array
 |  
 |  __array_wrap__(...)
 |      sc.__array_wrap__(obj) return scalar from array
 |  
 |  __copy__(...)
 |  
 |  __deepcopy__(...)
 |  
 |  __format__(...)
 |      NumPy array scalar formatter
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __round__(...)
 |  
 |  __setstate__(...)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  all(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  any(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmax(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmin(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argsort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  astype(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  byteswap(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  choose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  clip(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  compress(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  conj(...)
 |  
 |  conjugate(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  copy(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumprod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumsum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  diagonal(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dump(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dumps(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  fill(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  flatten(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  getfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  item(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  itemset(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  max(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  mean(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  min(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  newbyteorder(...)
 |      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.
 |      
 |      The `new_order` code can be any from the following:
 |      
 |      * 'S' - swap dtype from current to opposite endian
 |      * {'<', 'L'} - little endian
 |      * {'>', 'B'} - big endian
 |      * {'=', 'N'} - native order
 |      * {'|', 'I'} - ignore (no change to byte order)
 |      
 |      Parameters
 |      ----------
 |      new_order : str, optional
 |          Byte order to force; a value from the byte order specifications
 |          above.  The default value ('S') results in swapping the current
 |          byte order. The code does a case-insensitive check on the first
 |          letter of `new_order` for the alternatives above.  For example,
 |          any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 |      
 |      
 |      Returns
 |      -------
 |      new_dtype : dtype
 |          New `dtype` object with the given change to the byte order.
 |  
 |  nonzero(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  prod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ptp(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  put(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ravel(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  repeat(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  reshape(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  resize(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  round(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  searchsorted(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setflags(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  squeeze(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  std(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  swapaxes(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  take(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tobytes(...)
 |  
 |  tofile(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tolist(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tostring(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  trace(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  transpose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  var(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  view(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from generic:
 |  
 |  T
 |      transpose
 |  
 |  __array_interface__
 |      Array protocol: Python side
 |  
 |  __array_priority__
 |      Array priority.
 |  
 |  __array_struct__
 |      Array protocol: struct
 |  
 |  base
 |      base object
 |  
 |  data
 |      pointer to start of data
 |  
 |  dtype
 |      get array data-descriptor
 |  
 |  flags
 |      integer value of flags
 |  
 |  flat
 |      a 1-d view of scalar
 |  
 |  imag
 |      imaginary part of scalar
 |  
 |  itemsize
 |      length of one element in bytes
 |  
 |  nbytes
 |      length of item in bytes
 |  
 |  ndim
 |      number of array dimensions
 |  
 |  real
 |      real part of scalar
 |  
 |  shape
 |      tuple of array dimensions
 |  
 |  size
 |      number of elements in the gentype
 |  
 |  strides
 |      tuple of bytes steps in each dimension
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg.decomp_schur.single,linalg.decomp_schur,float32,"Python Library Documentation: class float32 in module numpy

class float32(floating)
 |  32-bit floating-point number. Character code 'f'. C float compatible.
 |  
 |  Method resolution order:
 |      float32
 |      floating
 |      inexact
 |      number
 |      generic
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from generic:
 |  
 |  __array__(...)
 |      sc.__array__(|type) return 0-dim array
 |  
 |  __array_wrap__(...)
 |      sc.__array_wrap__(obj) return scalar from array
 |  
 |  __copy__(...)
 |  
 |  __deepcopy__(...)
 |  
 |  __format__(...)
 |      NumPy array scalar formatter
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __round__(...)
 |  
 |  __setstate__(...)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  all(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  any(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmax(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmin(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argsort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  astype(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  byteswap(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  choose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  clip(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  compress(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  conj(...)
 |  
 |  conjugate(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  copy(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumprod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumsum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  diagonal(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dump(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dumps(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  fill(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  flatten(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  getfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  item(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  itemset(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  max(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  mean(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  min(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  newbyteorder(...)
 |      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.
 |      
 |      The `new_order` code can be any from the following:
 |      
 |      * 'S' - swap dtype from current to opposite endian
 |      * {'<', 'L'} - little endian
 |      * {'>', 'B'} - big endian
 |      * {'=', 'N'} - native order
 |      * {'|', 'I'} - ignore (no change to byte order)
 |      
 |      Parameters
 |      ----------
 |      new_order : str, optional
 |          Byte order to force; a value from the byte order specifications
 |          above.  The default value ('S') results in swapping the current
 |          byte order. The code does a case-insensitive check on the first
 |          letter of `new_order` for the alternatives above.  For example,
 |          any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 |      
 |      
 |      Returns
 |      -------
 |      new_dtype : dtype
 |          New `dtype` object with the given change to the byte order.
 |  
 |  nonzero(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  prod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ptp(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  put(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ravel(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  repeat(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  reshape(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  resize(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  round(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  searchsorted(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setflags(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  squeeze(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  std(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  swapaxes(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  take(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tobytes(...)
 |  
 |  tofile(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tolist(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tostring(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  trace(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  transpose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  var(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  view(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from generic:
 |  
 |  T
 |      transpose
 |  
 |  __array_interface__
 |      Array protocol: Python side
 |  
 |  __array_priority__
 |      Array priority.
 |  
 |  __array_struct__
 |      Array protocol: struct
 |  
 |  base
 |      base object
 |  
 |  data
 |      pointer to start of data
 |  
 |  dtype
 |      get array data-descriptor
 |  
 |  flags
 |      integer value of flags
 |  
 |  flat
 |      a 1-d view of scalar
 |  
 |  imag
 |      imaginary part of scalar
 |  
 |  itemsize
 |      length of one element in bytes
 |  
 |  nbytes
 |      length of item in bytes
 |  
 |  ndim
 |      number of array dimensions
 |  
 |  real
 |      real part of scalar
 |  
 |  shape
 |      tuple of array dimensions
 |  
 |  size
 |      number of elements in the gentype
 |  
 |  strides
 |      tuple of bytes steps in each dimension
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg.decomp_svd.LinAlgError,linalg.decomp_svd,LinAlgError,"Python Library Documentation: class LinAlgError in module numpy.linalg.linalg

class LinAlgError(builtins.Exception)
 |  Generic Python-exception-derived object raised by linalg functions.
 |  
 |  General purpose exception class, derived from Python's exception.Exception
 |  class, programmatically raised in linalg functions when a Linear
 |  Algebra-related condition would prevent further correct execution of the
 |  function.
 |  
 |  Parameters
 |  ----------
 |  None
 |  
 |  Examples
 |  --------
 |  >>> from numpy import linalg as LA
 |  >>> LA.inv(np.zeros((2,2)))
 |  Traceback (most recent call last):
 |    File ""<stdin>"", line 1, in <module>
 |    File ""...linalg.py"", line 350,
 |      in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
 |    File ""...linalg.py"", line 249,
 |      in solve
 |      raise LinAlgError('Singular matrix')
 |  numpy.linalg.LinAlgError: Singular matrix
 |  
 |  Method resolution order:
 |      LinAlgError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg.decomp_svd.LinAlgError,linalg.decomp_svd,LinAlgError,"Python Library Documentation: class LinAlgError in module numpy.linalg.linalg

class LinAlgError(builtins.Exception)
 |  Generic Python-exception-derived object raised by linalg functions.
 |  
 |  General purpose exception class, derived from Python's exception.Exception
 |  class, programmatically raised in linalg functions when a Linear
 |  Algebra-related condition would prevent further correct execution of the
 |  function.
 |  
 |  Parameters
 |  ----------
 |  None
 |  
 |  Examples
 |  --------
 |  >>> from numpy import linalg as LA
 |  >>> LA.inv(np.zeros((2,2)))
 |  Traceback (most recent call last):
 |    File ""<stdin>"", line 1, in <module>
 |    File ""...linalg.py"", line 350,
 |      in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
 |    File ""...linalg.py"", line 249,
 |      in solve
 |      raise LinAlgError('Singular matrix')
 |  numpy.linalg.LinAlgError: Singular matrix
 |  
 |  Method resolution order:
 |      LinAlgError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg.decomp_svd._asarray_validated,linalg.decomp_svd,_asarray_validated,"Python Library Documentation: function _asarray_validated in module scipy._lib._util

_asarray_validated(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)
    Helper function for scipy argument validation.
    
    Many scipy linear algebra functions do support arbitrary array-like
    input arguments.  Examples of commonly unsupported inputs include
    matrices containing inf/nan, sparse matrix representations, and
    matrices with complicated elements.
    
    Parameters
    ----------
    a : array_like
        The array-like input.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default: True
    sparse_ok : bool, optional
        True if scipy sparse matrices are allowed.
    objects_ok : bool, optional
        True if arrays with dype('O') are allowed.
    mask_ok : bool, optional
        True if masked arrays are allowed.
    as_inexact : bool, optional
        True to convert the input array to a np.inexact dtype.
    
    Returns
    -------
    ret : ndarray
        The converted validated array.
",function,"('(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)',)",scipy,1.1.0,scipy.linalg.decomp_svd._asarray_validated,linalg.decomp_svd,_asarray_validated,"Python Library Documentation: function _asarray_validated in module scipy._lib._util

_asarray_validated(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)
    Helper function for scipy argument validation.
    
    Many scipy linear algebra functions do support arbitrary array-like
    input arguments.  Examples of commonly unsupported inputs include
    matrices containing inf/nan, sparse matrix representations, and
    matrices with complicated elements.
    
    Parameters
    ----------
    a : array_like
        The array-like input.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default: True
    sparse_ok : bool, optional
        True if scipy sparse matrices are allowed.
    objects_ok : bool, optional
        True if arrays with dype('O') are allowed.
    mask_ok : bool, optional
        True if masked arrays are allowed.
    as_inexact : bool, optional
        True to convert the input array to a np.inexact dtype.
    
    Returns
    -------
    ret : ndarray
        The converted validated array.
",function,"('a', 'check_finite', 'sparse_ok', 'objects_ok', 'mask_ok', 'as_inexact')","(nan, True, False, False, False, False)","(nan, 'bool', 'bool', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, check_finite=True, sparse_ok=False, objects_ok=False, mask_ok=False, as_inexact=False)',)"
scipy,1.1.0,scipy.linalg.decomp_svd._compute_lwork,linalg.decomp_svd,_compute_lwork,"Python Library Documentation: function _compute_lwork in module scipy.linalg.lapack

_compute_lwork(routine, *args, **kwargs)
    Round floating-point lwork returned by lapack to integer.
    
    Several LAPACK routines compute optimal values for LWORK, which
    they return in a floating-point variable. However, for large
    values of LWORK, single-precision floating point is not sufficient
    to hold the exact value --- some LAPACK versions (<= 3.5.0 at
    least) truncate the returned integer to single precision and in
    some cases this can be smaller than the required value.
    
    Examples
    --------
    >>> from scipy.linalg import lapack
    >>> n = 5000
    >>> s_r, s_lw = lapack.get_lapack_funcs(('sysvx', 'sysvx_lwork'))
    >>> lwork = lapack._compute_lwork(s_lw, n)
    >>> lwork
    32000
",function,"('(routine, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg.decomp_svd._compute_lwork,linalg.decomp_svd,_compute_lwork,"Python Library Documentation: function _compute_lwork in module scipy.linalg.lapack

_compute_lwork(routine, *args, **kwargs)
    Round floating-point lwork returned by lapack to integer.
    
    Several LAPACK routines compute optimal values for LWORK, which
    they return in a floating-point variable. However, for large
    values of LWORK, single-precision floating point is not sufficient
    to hold the exact value --- some LAPACK versions (<= 3.5.0 at
    least) truncate the returned integer to single precision and in
    some cases this can be smaller than the required value.
    
    Examples
    --------
    >>> from scipy.linalg import lapack
    >>> n = 5000
    >>> s_r, s_lw = lapack.get_lapack_funcs(('sysvx', 'sysvx_lwork'))
    >>> lwork = lapack._compute_lwork(s_lw, n)
    >>> lwork
    32000
",function,"('routine',)","(nan,)","(nan,)","('arg_info',)","('(routine, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg.decomp_svd._datacopied,linalg.decomp_svd,_datacopied,"Python Library Documentation: function _datacopied in module scipy.linalg.misc

_datacopied(arr, original)
    Strict check for `arr` not sharing any data with `original`,
    under the assumption that arr = asarray(original)
",function,"('(arr, original)',)",scipy,1.1.0,scipy.linalg.decomp_svd._datacopied,linalg.decomp_svd,_datacopied,"Python Library Documentation: function _datacopied in module scipy.linalg.misc

_datacopied(arr, original)
    Strict check for `arr` not sharing any data with `original`,
    under the assumption that arr = asarray(original)
",function,"('arr', 'original')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(arr, original)',)"
scipy,1.1.0,scipy.linalg.decomp_svd.clip,linalg.decomp_svd,clip,"Python Library Documentation: function clip in module numpy.core.fromnumeric

clip(a, a_min, a_max, out=None)
    Clip (limit) the values in an array.
    
    Given an interval, values outside the interval are clipped to
    the interval edges.  For example, if an interval of ``[0, 1]``
    is specified, values smaller than 0 become 0, and values larger
    than 1 become 1.
    
    Parameters
    ----------
    a : array_like
        Array containing elements to clip.
    a_min : scalar or array_like or `None`
        Minimum value. If `None`, clipping is not performed on lower
        interval edge. Not more than one of `a_min` and `a_max` may be
        `None`.
    a_max : scalar or array_like or `None`
        Maximum value. If `None`, clipping is not performed on upper
        interval edge. Not more than one of `a_min` and `a_max` may be
        `None`. If `a_min` or `a_max` are array_like, then the three
        arrays will be broadcasted to match their shapes.
    out : ndarray, optional
        The results will be placed in this array. It may be the input
        array for in-place clipping.  `out` must be of the right shape
        to hold the output.  Its type is preserved.
    
    Returns
    -------
    clipped_array : ndarray
        An array with the elements of `a`, but where values
        < `a_min` are replaced with `a_min`, and those > `a_max`
        with `a_max`.
    
    See Also
    --------
    numpy.doc.ufuncs : Section ""Output arguments""
    
    Examples
    --------
    >>> a = np.arange(10)
    >>> np.clip(a, 1, 8)
    array([1, 1, 2, 3, 4, 5, 6, 7, 8, 8])
    >>> a
    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    >>> np.clip(a, 3, 6, out=a)
    array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6])
    >>> a = np.arange(10)
    >>> a
    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    >>> np.clip(a, [3, 4, 1, 1, 1, 4, 4, 4, 4, 4], 8)
    array([3, 4, 2, 3, 4, 5, 6, 7, 8, 8])
",function,"('(a, a_min, a_max, out=None)',)",scipy,1.1.0,scipy.linalg.decomp_svd.clip,linalg.decomp_svd,clip,"Python Library Documentation: function clip in module numpy.core.fromnumeric

clip(a, a_min, a_max, out=None)
    Clip (limit) the values in an array.
    
    Given an interval, values outside the interval are clipped to
    the interval edges.  For example, if an interval of ``[0, 1]``
    is specified, values smaller than 0 become 0, and values larger
    than 1 become 1.
    
    Parameters
    ----------
    a : array_like
        Array containing elements to clip.
    a_min : scalar or array_like or `None`
        Minimum value. If `None`, clipping is not performed on lower
        interval edge. Not more than one of `a_min` and `a_max` may be
        `None`.
    a_max : scalar or array_like or `None`
        Maximum value. If `None`, clipping is not performed on upper
        interval edge. Not more than one of `a_min` and `a_max` may be
        `None`. If `a_min` or `a_max` are array_like, then the three
        arrays will be broadcasted to match their shapes.
    out : ndarray, optional
        The results will be placed in this array. It may be the input
        array for in-place clipping.  `out` must be of the right shape
        to hold the output.  Its type is preserved.
    
    Returns
    -------
    clipped_array : ndarray
        An array with the elements of `a`, but where values
        < `a_min` are replaced with `a_min`, and those > `a_max`
        with `a_max`.
    
    See Also
    --------
    numpy.doc.ufuncs : Section ""Output arguments""
    
    Examples
    --------
    >>> a = np.arange(10)
    >>> np.clip(a, 1, 8)
    array([1, 1, 2, 3, 4, 5, 6, 7, 8, 8])
    >>> a
    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    >>> np.clip(a, 3, 6, out=a)
    array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6])
    >>> a = np.arange(10)
    >>> a
    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    >>> np.clip(a, [3, 4, 1, 1, 1, 4, 4, 4, 4, 4], 8)
    array([3, 4, 2, 3, 4, 5, 6, 7, 8, 8])
",function,"('a', 'a_min', 'a_max', 'out')","(nan, nan, nan, None)","(nan, nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, a_min, a_max, out=None)',)"
scipy,1.1.0,scipy.linalg.decomp_svd.diag,linalg.decomp_svd,diag,"Python Library Documentation: function diag in module numpy.lib.twodim_base

diag(v, k=0)
    Extract a diagonal or construct a diagonal array.
    
    See the more detailed documentation for ``numpy.diagonal`` if you use this
    function to extract a diagonal and wish to write to the resulting array;
    whether it returns a copy or a view depends on what version of numpy you
    are using.
    
    Parameters
    ----------
    v : array_like
        If `v` is a 2-D array, return a copy of its `k`-th diagonal.
        If `v` is a 1-D array, return a 2-D array with `v` on the `k`-th
        diagonal.
    k : int, optional
        Diagonal in question. The default is 0. Use `k>0` for diagonals
        above the main diagonal, and `k<0` for diagonals below the main
        diagonal.
    
    Returns
    -------
    out : ndarray
        The extracted diagonal or constructed diagonal array.
    
    See Also
    --------
    diagonal : Return specified diagonals.
    diagflat : Create a 2-D array with the flattened input as a diagonal.
    trace : Sum along diagonals.
    triu : Upper triangle of an array.
    tril : Lower triangle of an array.
    
    Examples
    --------
    >>> x = np.arange(9).reshape((3,3))
    >>> x
    array([[0, 1, 2],
           [3, 4, 5],
           [6, 7, 8]])
    
    >>> np.diag(x)
    array([0, 4, 8])
    >>> np.diag(x, k=1)
    array([1, 5])
    >>> np.diag(x, k=-1)
    array([3, 7])
    
    >>> np.diag(np.diag(x))
    array([[0, 0, 0],
           [0, 4, 0],
           [0, 0, 8]])
",function,"('(v, k=0)',)",scipy,1.1.0,scipy.linalg.decomp_svd.diag,linalg.decomp_svd,diag,"Python Library Documentation: function diag in module numpy.lib.twodim_base

diag(v, k=0)
    Extract a diagonal or construct a diagonal array.
    
    See the more detailed documentation for ``numpy.diagonal`` if you use this
    function to extract a diagonal and wish to write to the resulting array;
    whether it returns a copy or a view depends on what version of numpy you
    are using.
    
    Parameters
    ----------
    v : array_like
        If `v` is a 2-D array, return a copy of its `k`-th diagonal.
        If `v` is a 1-D array, return a 2-D array with `v` on the `k`-th
        diagonal.
    k : int, optional
        Diagonal in question. The default is 0. Use `k>0` for diagonals
        above the main diagonal, and `k<0` for diagonals below the main
        diagonal.
    
    Returns
    -------
    out : ndarray
        The extracted diagonal or constructed diagonal array.
    
    See Also
    --------
    diagonal : Return specified diagonals.
    diagflat : Create a 2-D array with the flattened input as a diagonal.
    trace : Sum along diagonals.
    triu : Upper triangle of an array.
    tril : Lower triangle of an array.
    
    Examples
    --------
    >>> x = np.arange(9).reshape((3,3))
    >>> x
    array([[0, 1, 2],
           [3, 4, 5],
           [6, 7, 8]])
    
    >>> np.diag(x)
    array([0, 4, 8])
    >>> np.diag(x, k=1)
    array([1, 5])
    >>> np.diag(x, k=-1)
    array([3, 7])
    
    >>> np.diag(np.diag(x))
    array([[0, 0, 0],
           [0, 4, 0],
           [0, 0, 8]])
",function,"('v', 'k')","(nan, 0)","(nan, 'int')","('arg_info', 'arg_info')","('(v, k=0)',)"
scipy,1.1.0,scipy.linalg.decomp_svd.diagsvd,linalg.decomp_svd,diagsvd,"Python Library Documentation: function diagsvd in module scipy.linalg.decomp_svd

diagsvd(s, M, N)
    Construct the sigma matrix in SVD from singular values and size M, N.
    
    Parameters
    ----------
    s : (M,) or (N,) array_like
        Singular values
    M : int
        Size of the matrix whose singular values are `s`.
    N : int
        Size of the matrix whose singular values are `s`.
    
    Returns
    -------
    S : (M, N) ndarray
        The S-matrix in the singular value decomposition
    
    See Also
    --------
    svd : Singular value decomposition of a matrix
    svdvals : Compute singular values of a matrix.
    
    Examples
    --------
    >>> from scipy.linalg import diagsvd
    >>> vals = np.array([1, 2, 3])  # The array representing the computed svd
    >>> diagsvd(vals, 3, 4)
    array([[1, 0, 0, 0],
           [0, 2, 0, 0],
           [0, 0, 3, 0]])
    >>> diagsvd(vals, 4, 3)
    array([[1, 0, 0],
           [0, 2, 0],
           [0, 0, 3],
           [0, 0, 0]])
",function,"('(s, M, N)',)",scipy,1.1.0,scipy.linalg.decomp_svd.diagsvd,linalg.decomp_svd,diagsvd,"Python Library Documentation: function diagsvd in module scipy.linalg.decomp_svd

diagsvd(s, M, N)
    Construct the sigma matrix in SVD from singular values and size M, N.
    
    Parameters
    ----------
    s : (M,) or (N,) array_like
        Singular values
    M : int
        Size of the matrix whose singular values are `s`.
    N : int
        Size of the matrix whose singular values are `s`.
    
    Returns
    -------
    S : (M, N) ndarray
        The S-matrix in the singular value decomposition
    
    See Also
    --------
    svd : Singular value decomposition of a matrix
    svdvals : Compute singular values of a matrix.
    
    Examples
    --------
    >>> from scipy.linalg import diagsvd
    >>> vals = np.array([1, 2, 3])  # The array representing the computed svd
    >>> diagsvd(vals, 3, 4)
    array([[1, 0, 0, 0],
           [0, 2, 0, 0],
           [0, 0, 3, 0]])
    >>> diagsvd(vals, 4, 3)
    array([[1, 0, 0],
           [0, 2, 0],
           [0, 0, 3],
           [0, 0, 0]])
",function,"('s', 'M', 'N')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(s, M, N)',)"
scipy,1.1.0,scipy.linalg.decomp_svd.get_lapack_funcs,linalg.decomp_svd,get_lapack_funcs,"Python Library Documentation: function get_lapack_funcs in module scipy.linalg.lapack

get_lapack_funcs(names, arrays=(), dtype=None)
    Return available LAPACK function objects from names.
    
    Arrays are used to determine the optimal prefix of LAPACK routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of LAPACK functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of LAPACK
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In LAPACK, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively, and
    are stored in attribute ``typecode`` of the returned functions.
    
    Examples
    --------
    Suppose we would like to use '?lange' routine which computes the selected
    norm of an array. We pass our array in order to get the correct 'lange'
    flavor.
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_lange = LA.get_lapack_funcs('lange', (a,))
    >>> x_lange.typecode
    'd'
    >>> x_lange = LA.get_lapack_funcs('lange',(a*1j,))
    >>> x_lange.typecode
    'z'
    
    Several LAPACK routines work best when its internal WORK array has
    the optimal size (big enough for fast computation and small enough to
    avoid waste of memory). This size is determined also by a dedicated query
    to the function which is often wrapped as a standalone function and
    commonly denoted as ``###_lwork``. Below is an example for ``?sysv``
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(1000,1000)
    >>> b = np.random.rand(1000,1)*1j
    >>> # We pick up zsysv and zsysv_lwork due to b array
    ... xsysv, xlwork = LA.get_lapack_funcs(('sysv', 'sysv_lwork'), (a, b))
    >>> opt_lwork, _ = xlwork(a.shape[0])  # returns a complex for 'z' prefix
    >>> udut, ipiv, x, info = xsysv(a, b, lwork=int(opt_lwork.real))
",function,"('(names, arrays=(), dtype=None)',)",scipy,1.1.0,scipy.linalg.decomp_svd.get_lapack_funcs,linalg.decomp_svd,get_lapack_funcs,"Python Library Documentation: function get_lapack_funcs in module scipy.linalg.lapack

get_lapack_funcs(names, arrays=(), dtype=None)
    Return available LAPACK function objects from names.
    
    Arrays are used to determine the optimal prefix of LAPACK routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of LAPACK functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of LAPACK
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In LAPACK, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively, and
    are stored in attribute ``typecode`` of the returned functions.
    
    Examples
    --------
    Suppose we would like to use '?lange' routine which computes the selected
    norm of an array. We pass our array in order to get the correct 'lange'
    flavor.
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_lange = LA.get_lapack_funcs('lange', (a,))
    >>> x_lange.typecode
    'd'
    >>> x_lange = LA.get_lapack_funcs('lange',(a*1j,))
    >>> x_lange.typecode
    'z'
    
    Several LAPACK routines work best when its internal WORK array has
    the optimal size (big enough for fast computation and small enough to
    avoid waste of memory). This size is determined also by a dedicated query
    to the function which is often wrapped as a standalone function and
    commonly denoted as ``###_lwork``. Below is an example for ``?sysv``
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(1000,1000)
    >>> b = np.random.rand(1000,1)*1j
    >>> # We pick up zsysv and zsysv_lwork due to b array
    ... xsysv, xlwork = LA.get_lapack_funcs(('sysv', 'sysv_lwork'), (a, b))
    >>> opt_lwork, _ = xlwork(a.shape[0])  # returns a complex for 'z' prefix
    >>> udut, ipiv, x, info = xsysv(a, b, lwork=int(opt_lwork.real))
",function,"('names', 'arrays', 'dtype')","(nan, (), None)","(nan, 'tuple', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(names, arrays=(), dtype=None)',)"
scipy,1.1.0,scipy.linalg.decomp_svd.null_space,linalg.decomp_svd,null_space,"Python Library Documentation: function null_space in module scipy.linalg.decomp_svd

null_space(A, rcond=None)
    Construct an orthonormal basis for the null space of A using SVD
    
    Parameters
    ----------
    A : (M, N) array_like
        Input array
    rcond : float, optional
        Relative condition number. Singular values ``s`` smaller than
        ``rcond * max(s)`` are considered zero.
        Default: floating point eps * max(M,N).
    
    Returns
    -------
    Z : (N, K) ndarray
        Orthonormal basis for the null space of A.
        K = dimension of effective null space, as determined by rcond
    
    See also
    --------
    svd : Singular value decomposition of a matrix
    orth : Matrix range
    
    Examples
    --------
    One-dimensional null space:
    
    >>> from scipy.linalg import null_space
    >>> A = np.array([[1, 1], [1, 1]])
    >>> ns = null_space(A)
    >>> ns * np.sign(ns[0,0])  # Remove the sign ambiguity of the vector
    array([[ 0.70710678],
           [-0.70710678]])
    
    Two-dimensional null space:
    
    >>> B = np.random.rand(3, 5)
    >>> Z = null_space(B)
    >>> Z.shape
    (5, 2)
    >>> np.allclose(B.dot(Z), 0)
    True
    
    The basis vectors are orthonormal (up to rounding error):
    
    >>> Z.T.dot(Z)
    array([[  1.00000000e+00,   6.92087741e-17],
           [  6.92087741e-17,   1.00000000e+00]])
",function,"('(A, rcond=None)',)",scipy,1.1.0,scipy.linalg.decomp_svd.null_space,linalg.decomp_svd,null_space,"Python Library Documentation: function null_space in module scipy.linalg.decomp_svd

null_space(A, rcond=None)
    Construct an orthonormal basis for the null space of A using SVD
    
    Parameters
    ----------
    A : (M, N) array_like
        Input array
    rcond : float, optional
        Relative condition number. Singular values ``s`` smaller than
        ``rcond * max(s)`` are considered zero.
        Default: floating point eps * max(M,N).
    
    Returns
    -------
    Z : (N, K) ndarray
        Orthonormal basis for the null space of A.
        K = dimension of effective null space, as determined by rcond
    
    See also
    --------
    svd : Singular value decomposition of a matrix
    orth : Matrix range
    
    Examples
    --------
    One-dimensional null space:
    
    >>> from scipy.linalg import null_space
    >>> A = np.array([[1, 1], [1, 1]])
    >>> ns = null_space(A)
    >>> ns * np.sign(ns[0,0])  # Remove the sign ambiguity of the vector
    array([[ 0.70710678],
           [-0.70710678]])
    
    Two-dimensional null space:
    
    >>> B = np.random.rand(3, 5)
    >>> Z = null_space(B)
    >>> Z.shape
    (5, 2)
    >>> np.allclose(B.dot(Z), 0)
    True
    
    The basis vectors are orthonormal (up to rounding error):
    
    >>> Z.T.dot(Z)
    array([[  1.00000000e+00,   6.92087741e-17],
           [  6.92087741e-17,   1.00000000e+00]])
",function,"('A', 'rcond')","(nan, None)","(nan, 'NoneType')","('arg_info', 'arg_info')","('(A, rcond=None)',)"
scipy,1.1.0,scipy.linalg.decomp_svd.orth,linalg.decomp_svd,orth,"Python Library Documentation: function orth in module scipy.linalg.decomp_svd

orth(A, rcond=None)
    Construct an orthonormal basis for the range of A using SVD
    
    Parameters
    ----------
    A : (M, N) array_like
        Input array
    rcond : float, optional
        Relative condition number. Singular values ``s`` smaller than
        ``rcond * max(s)`` are considered zero.
        Default: floating point eps * max(M,N).
    
    Returns
    -------
    Q : (M, K) ndarray
        Orthonormal basis for the range of A.
        K = effective rank of A, as determined by rcond
    
    See also
    --------
    svd : Singular value decomposition of a matrix
    null_space : Matrix null space
    
    Examples
    --------
    >>> from scipy.linalg import orth
    >>> A = np.array([[2, 0, 0], [0, 5, 0]])  # rank 2 array
    >>> orth(A)
    array([[0., 1.],
           [1., 0.]])
    >>> orth(A.T)
    array([[0., 1.],
           [1., 0.],
           [0., 0.]])
",function,"('(A, rcond=None)',)",scipy,1.1.0,scipy.linalg.decomp_svd.orth,linalg.decomp_svd,orth,"Python Library Documentation: function orth in module scipy.linalg.decomp_svd

orth(A, rcond=None)
    Construct an orthonormal basis for the range of A using SVD
    
    Parameters
    ----------
    A : (M, N) array_like
        Input array
    rcond : float, optional
        Relative condition number. Singular values ``s`` smaller than
        ``rcond * max(s)`` are considered zero.
        Default: floating point eps * max(M,N).
    
    Returns
    -------
    Q : (M, K) ndarray
        Orthonormal basis for the range of A.
        K = effective rank of A, as determined by rcond
    
    See also
    --------
    svd : Singular value decomposition of a matrix
    null_space : Matrix null space
    
    Examples
    --------
    >>> from scipy.linalg import orth
    >>> A = np.array([[2, 0, 0], [0, 5, 0]])  # rank 2 array
    >>> orth(A)
    array([[0., 1.],
           [1., 0.]])
    >>> orth(A.T)
    array([[0., 1.],
           [1., 0.],
           [0., 0.]])
",function,"('A', 'rcond')","(nan, None)","(nan, 'NoneType')","('arg_info', 'arg_info')","('(A, rcond=None)',)"
scipy,1.1.0,scipy.linalg.decomp_svd.subspace_angles,linalg.decomp_svd,subspace_angles,"Python Library Documentation: function subspace_angles in module scipy.linalg.decomp_svd

subspace_angles(A, B)
    Compute the subspace angles between two matrices.
    
    Parameters
    ----------
    A : (M, N) array_like
        The first input array.
    B : (M, K) array_like
        The second input array.
    
    Returns
    -------
    angles : ndarray, shape (min(N, K),)
        The subspace angles between the column spaces of `A` and `B`.
    
    See Also
    --------
    orth
    svd
    
    Notes
    -----
    This computes the subspace angles according to the formula
    provided in [1]_. For equivalence with MATLAB and Octave behavior,
    use ``angles[0]``.
    
    .. versionadded:: 1.0
    
    References
    ----------
    .. [1] Knyazev A, Argentati M (2002) Principal Angles between Subspaces
           in an A-Based Scalar Product: Algorithms and Perturbation
           Estimates. SIAM J. Sci. Comput. 23:2008-2040.
    
    Examples
    --------
    A Hadamard matrix, which has orthogonal columns, so we expect that
    the suspace angle to be :math:`\frac{\pi}{2}`:
    
    >>> from scipy.linalg import hadamard, subspace_angles
    >>> H = hadamard(4)
    >>> print(H)
    [[ 1  1  1  1]
     [ 1 -1  1 -1]
     [ 1  1 -1 -1]
     [ 1 -1 -1  1]]
    >>> np.rad2deg(subspace_angles(H[:, :2], H[:, 2:]))
    array([ 90.,  90.])
    
    And the subspace angle of a matrix to itself should be zero:
    
    >>> subspace_angles(H[:, :2], H[:, :2]) <= 2 * np.finfo(float).eps
    array([ True,  True], dtype=bool)
    
    The angles between non-orthogonal subspaces are in between these extremes:
    
    >>> x = np.random.RandomState(0).randn(4, 3)
    >>> np.rad2deg(subspace_angles(x[:, :2], x[:, [2]]))
    array([ 55.832])
",function,"('(A, B)',)",scipy,1.1.0,scipy.linalg.decomp_svd.subspace_angles,linalg.decomp_svd,subspace_angles,"Python Library Documentation: function subspace_angles in module scipy.linalg.decomp_svd

subspace_angles(A, B)
    Compute the subspace angles between two matrices.
    
    Parameters
    ----------
    A : (M, N) array_like
        The first input array.
    B : (M, K) array_like
        The second input array.
    
    Returns
    -------
    angles : ndarray, shape (min(N, K),)
        The subspace angles between the column spaces of `A` and `B`.
    
    See Also
    --------
    orth
    svd
    
    Notes
    -----
    This computes the subspace angles according to the formula
    provided in [1]_. For equivalence with MATLAB and Octave behavior,
    use ``angles[0]``.
    
    .. versionadded:: 1.0
    
    References
    ----------
    .. [1] Knyazev A, Argentati M (2002) Principal Angles between Subspaces
           in an A-Based Scalar Product: Algorithms and Perturbation
           Estimates. SIAM J. Sci. Comput. 23:2008-2040.
    
    Examples
    --------
    A Hadamard matrix, which has orthogonal columns, so we expect that
    the suspace angle to be :math:`\frac{\pi}{2}`:
    
    >>> from scipy.linalg import hadamard, subspace_angles
    >>> H = hadamard(4)
    >>> print(H)
    [[ 1  1  1  1]
     [ 1 -1  1 -1]
     [ 1  1 -1 -1]
     [ 1 -1 -1  1]]
    >>> np.rad2deg(subspace_angles(H[:, :2], H[:, 2:]))
    array([ 90.,  90.])
    
    And the subspace angle of a matrix to itself should be zero:
    
    >>> subspace_angles(H[:, :2], H[:, :2]) <= 2 * np.finfo(float).eps
    array([ True,  True], dtype=bool)
    
    The angles between non-orthogonal subspaces are in between these extremes:
    
    >>> x = np.random.RandomState(0).randn(4, 3)
    >>> np.rad2deg(subspace_angles(x[:, :2], x[:, [2]]))
    array([ 55.832])
",function,"('A', 'B')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(A, B)',)"
scipy,1.1.0,scipy.linalg.decomp_svd.svd,linalg.decomp_svd,svd,"Python Library Documentation: function svd in module scipy.linalg.decomp_svd

svd(a, full_matrices=True, compute_uv=True, overwrite_a=False, check_finite=True, lapack_driver='gesdd')
    Singular Value Decomposition.
    
    Factorizes the matrix `a` into two unitary matrices ``U`` and ``Vh``, and
    a 1-D array ``s`` of singular values (real, non-negative) such that
    ``a == U @ S @ Vh``, where ``S`` is a suitably shaped matrix of zeros with
    main diagonal ``s``.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to decompose.
    full_matrices : bool, optional
        If True (default), `U` and `Vh` are of shape ``(M, M)``, ``(N, N)``.
        If False, the shapes are ``(M, K)`` and ``(K, N)``, where
        ``K = min(M, N)``.
    compute_uv : bool, optional
        Whether to compute also ``U`` and ``Vh`` in addition to ``s``.
        Default is True.
    overwrite_a : bool, optional
        Whether to overwrite `a`; may improve performance.
        Default is False.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    lapack_driver : {'gesdd', 'gesvd'}, optional
        Whether to use the more efficient divide-and-conquer approach
        (``'gesdd'``) or general rectangular approach (``'gesvd'``)
        to compute the SVD. MATLAB and Octave use the ``'gesvd'`` approach.
        Default is ``'gesdd'``.
    
        .. versionadded:: 0.18
    
    Returns
    -------
    U : ndarray
        Unitary matrix having left singular vectors as columns.
        Of shape ``(M, M)`` or ``(M, K)``, depending on `full_matrices`.
    s : ndarray
        The singular values, sorted in non-increasing order.
        Of shape (K,), with ``K = min(M, N)``.
    Vh : ndarray
        Unitary matrix having right singular vectors as rows.
        Of shape ``(N, N)`` or ``(K, N)`` depending on `full_matrices`.
    
    For ``compute_uv=False``, only ``s`` is returned.
    
    Raises
    ------
    LinAlgError
        If SVD computation does not converge.
    
    See also
    --------
    svdvals : Compute singular values of a matrix.
    diagsvd : Construct the Sigma matrix, given the vector s.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> m, n = 9, 6
    >>> a = np.random.randn(m, n) + 1.j*np.random.randn(m, n)
    >>> U, s, Vh = linalg.svd(a)
    >>> U.shape,  s.shape, Vh.shape
    ((9, 9), (6,), (6, 6))
    
    Reconstruct the original matrix from the decomposition:
    
    >>> sigma = np.zeros((m, n))
    >>> for i in range(min(m, n)):
    ...     sigma[i, i] = s[i]
    >>> a1 = np.dot(U, np.dot(sigma, Vh))
    >>> np.allclose(a, a1)
    True
    
    Alternatively, use ``full_matrices=False`` (notice that the shape of
    ``U`` is then ``(m, n)`` instead of ``(m, m)``):
    
    >>> U, s, Vh = linalg.svd(a, full_matrices=False)
    >>> U.shape, s.shape, Vh.shape
    ((9, 6), (6,), (6, 6))
    >>> S = np.diag(s)
    >>> np.allclose(a, np.dot(U, np.dot(S, Vh)))
    True
    
    >>> s2 = linalg.svd(a, compute_uv=False)
    >>> np.allclose(s, s2)
    True
",function,"(""(a, full_matrices=True, compute_uv=True, overwrite_a=False, check_finite=True, lapack_driver='gesdd')"",)",scipy,1.1.0,scipy.linalg.decomp_svd.svd,linalg.decomp_svd,svd,"Python Library Documentation: function svd in module scipy.linalg.decomp_svd

svd(a, full_matrices=True, compute_uv=True, overwrite_a=False, check_finite=True, lapack_driver='gesdd')
    Singular Value Decomposition.
    
    Factorizes the matrix `a` into two unitary matrices ``U`` and ``Vh``, and
    a 1-D array ``s`` of singular values (real, non-negative) such that
    ``a == U @ S @ Vh``, where ``S`` is a suitably shaped matrix of zeros with
    main diagonal ``s``.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to decompose.
    full_matrices : bool, optional
        If True (default), `U` and `Vh` are of shape ``(M, M)``, ``(N, N)``.
        If False, the shapes are ``(M, K)`` and ``(K, N)``, where
        ``K = min(M, N)``.
    compute_uv : bool, optional
        Whether to compute also ``U`` and ``Vh`` in addition to ``s``.
        Default is True.
    overwrite_a : bool, optional
        Whether to overwrite `a`; may improve performance.
        Default is False.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    lapack_driver : {'gesdd', 'gesvd'}, optional
        Whether to use the more efficient divide-and-conquer approach
        (``'gesdd'``) or general rectangular approach (``'gesvd'``)
        to compute the SVD. MATLAB and Octave use the ``'gesvd'`` approach.
        Default is ``'gesdd'``.
    
        .. versionadded:: 0.18
    
    Returns
    -------
    U : ndarray
        Unitary matrix having left singular vectors as columns.
        Of shape ``(M, M)`` or ``(M, K)``, depending on `full_matrices`.
    s : ndarray
        The singular values, sorted in non-increasing order.
        Of shape (K,), with ``K = min(M, N)``.
    Vh : ndarray
        Unitary matrix having right singular vectors as rows.
        Of shape ``(N, N)`` or ``(K, N)`` depending on `full_matrices`.
    
    For ``compute_uv=False``, only ``s`` is returned.
    
    Raises
    ------
    LinAlgError
        If SVD computation does not converge.
    
    See also
    --------
    svdvals : Compute singular values of a matrix.
    diagsvd : Construct the Sigma matrix, given the vector s.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> m, n = 9, 6
    >>> a = np.random.randn(m, n) + 1.j*np.random.randn(m, n)
    >>> U, s, Vh = linalg.svd(a)
    >>> U.shape,  s.shape, Vh.shape
    ((9, 9), (6,), (6, 6))
    
    Reconstruct the original matrix from the decomposition:
    
    >>> sigma = np.zeros((m, n))
    >>> for i in range(min(m, n)):
    ...     sigma[i, i] = s[i]
    >>> a1 = np.dot(U, np.dot(sigma, Vh))
    >>> np.allclose(a, a1)
    True
    
    Alternatively, use ``full_matrices=False`` (notice that the shape of
    ``U`` is then ``(m, n)`` instead of ``(m, m)``):
    
    >>> U, s, Vh = linalg.svd(a, full_matrices=False)
    >>> U.shape, s.shape, Vh.shape
    ((9, 6), (6,), (6, 6))
    >>> S = np.diag(s)
    >>> np.allclose(a, np.dot(U, np.dot(S, Vh)))
    True
    
    >>> s2 = linalg.svd(a, compute_uv=False)
    >>> np.allclose(s, s2)
    True
",function,"('a', 'full_matrices', 'compute_uv', 'overwrite_a', 'check_finite', 'lapack_driver')","(nan, True, True, False, True, 'gesdd')","(nan, 'bool', 'bool', 'bool', 'bool', 'str')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a, full_matrices=True, compute_uv=True, overwrite_a=False, check_finite=True, lapack_driver='gesdd')"",)"
scipy,1.1.0,scipy.linalg.decomp_svd.svdvals,linalg.decomp_svd,svdvals,"Python Library Documentation: function svdvals in module scipy.linalg.decomp_svd

svdvals(a, overwrite_a=False, check_finite=True)
    Compute singular values of a matrix.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to decompose.
    overwrite_a : bool, optional
        Whether to overwrite `a`; may improve performance.
        Default is False.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    s : (min(M, N),) ndarray
        The singular values, sorted in decreasing order.
    
    Raises
    ------
    LinAlgError
        If SVD computation does not converge.
    
    Notes
    -----
    ``svdvals(a)`` only differs from ``svd(a, compute_uv=False)`` by its
    handling of the edge case of empty ``a``, where it returns an
    empty sequence:
    
    >>> a = np.empty((0, 2))
    >>> from scipy.linalg import svdvals
    >>> svdvals(a)
    array([], dtype=float64)
    
    See Also
    --------
    svd : Compute the full singular value decomposition of a matrix.
    diagsvd : Construct the Sigma matrix, given the vector s.
    
    Examples
    --------
    >>> from scipy.linalg import svdvals
    >>> m = np.array([[1.0, 0.0],
    ...               [2.0, 3.0],
    ...               [1.0, 1.0],
    ...               [0.0, 2.0],
    ...               [1.0, 0.0]])
    >>> svdvals(m)
    array([ 4.28091555,  1.63516424])
    
    We can verify the maximum singular value of `m` by computing the maximum
    length of `m.dot(u)` over all the unit vectors `u` in the (x,y) plane.
    We approximate ""all"" the unit vectors with a large sample.  Because
    of linearity, we only need the unit vectors with angles in [0, pi].
    
    >>> t = np.linspace(0, np.pi, 2000)
    >>> u = np.array([np.cos(t), np.sin(t)])
    >>> np.linalg.norm(m.dot(u), axis=0).max()
    4.2809152422538475
    
    `p` is a projection matrix with rank 1.  With exact arithmetic,
    its singular values would be [1, 0, 0, 0].
    
    >>> v = np.array([0.1, 0.3, 0.9, 0.3])
    >>> p = np.outer(v, v)
    >>> svdvals(p)
    array([  1.00000000e+00,   2.02021698e-17,   1.56692500e-17,
             8.15115104e-34])
    
    The singular values of an orthogonal matrix are all 1.  Here we
    create a random orthogonal matrix by using the `rvs()` method of
    `scipy.stats.ortho_group`.
    
    >>> from scipy.stats import ortho_group
    >>> np.random.seed(123)
    >>> orth = ortho_group.rvs(4)
    >>> svdvals(orth)
    array([ 1.,  1.,  1.,  1.])
",function,"('(a, overwrite_a=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.decomp_svd.svdvals,linalg.decomp_svd,svdvals,"Python Library Documentation: function svdvals in module scipy.linalg.decomp_svd

svdvals(a, overwrite_a=False, check_finite=True)
    Compute singular values of a matrix.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to decompose.
    overwrite_a : bool, optional
        Whether to overwrite `a`; may improve performance.
        Default is False.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    s : (min(M, N),) ndarray
        The singular values, sorted in decreasing order.
    
    Raises
    ------
    LinAlgError
        If SVD computation does not converge.
    
    Notes
    -----
    ``svdvals(a)`` only differs from ``svd(a, compute_uv=False)`` by its
    handling of the edge case of empty ``a``, where it returns an
    empty sequence:
    
    >>> a = np.empty((0, 2))
    >>> from scipy.linalg import svdvals
    >>> svdvals(a)
    array([], dtype=float64)
    
    See Also
    --------
    svd : Compute the full singular value decomposition of a matrix.
    diagsvd : Construct the Sigma matrix, given the vector s.
    
    Examples
    --------
    >>> from scipy.linalg import svdvals
    >>> m = np.array([[1.0, 0.0],
    ...               [2.0, 3.0],
    ...               [1.0, 1.0],
    ...               [0.0, 2.0],
    ...               [1.0, 0.0]])
    >>> svdvals(m)
    array([ 4.28091555,  1.63516424])
    
    We can verify the maximum singular value of `m` by computing the maximum
    length of `m.dot(u)` over all the unit vectors `u` in the (x,y) plane.
    We approximate ""all"" the unit vectors with a large sample.  Because
    of linearity, we only need the unit vectors with angles in [0, pi].
    
    >>> t = np.linspace(0, np.pi, 2000)
    >>> u = np.array([np.cos(t), np.sin(t)])
    >>> np.linalg.norm(m.dot(u), axis=0).max()
    4.2809152422538475
    
    `p` is a projection matrix with rank 1.  With exact arithmetic,
    its singular values would be [1, 0, 0, 0].
    
    >>> v = np.array([0.1, 0.3, 0.9, 0.3])
    >>> p = np.outer(v, v)
    >>> svdvals(p)
    array([  1.00000000e+00,   2.02021698e-17,   1.56692500e-17,
             8.15115104e-34])
    
    The singular values of an orthogonal matrix are all 1.  Here we
    create a random orthogonal matrix by using the `rvs()` method of
    `scipy.stats.ortho_group`.
    
    >>> from scipy.stats import ortho_group
    >>> np.random.seed(123)
    >>> orth = ortho_group.rvs(4)
    >>> svdvals(orth)
    array([ 1.,  1.,  1.,  1.])
",function,"('a', 'overwrite_a', 'check_finite')","(nan, False, True)","(nan, 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info')","('(a, overwrite_a=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.det,linalg,det,"Python Library Documentation: function det in module scipy.linalg.basic

det(a, overwrite_a=False, check_finite=True)
    Compute the determinant of a matrix
    
    The determinant of a square matrix is a value derived arithmetically
    from the coefficients of the matrix.
    
    The determinant for a 3x3 matrix, for example, is computed as follows::
    
        a    b    c
        d    e    f = A
        g    h    i
    
        det(A) = a*e*i + b*f*g + c*d*h - c*e*g - b*d*i - a*f*h
    
    Parameters
    ----------
    a : (M, M) array_like
        A square matrix.
    overwrite_a : bool, optional
        Allow overwriting data in a (may enhance performance).
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    det : float or complex
        Determinant of `a`.
    
    Notes
    -----
    The determinant is computed via LU factorization, LAPACK routine z/dgetrf.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.array([[1,2,3], [4,5,6], [7,8,9]])
    >>> linalg.det(a)
    0.0
    >>> a = np.array([[0,2,3], [4,5,6], [7,8,9]])
    >>> linalg.det(a)
    3.0
",function,"('(a, overwrite_a=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.det,linalg,det,"Python Library Documentation: function det in module scipy.linalg.basic

det(a, overwrite_a=False, check_finite=True)
    Compute the determinant of a matrix
    
    The determinant of a square matrix is a value derived arithmetically
    from the coefficients of the matrix.
    
    The determinant for a 3x3 matrix, for example, is computed as follows::
    
        a    b    c
        d    e    f = A
        g    h    i
    
        det(A) = a*e*i + b*f*g + c*d*h - c*e*g - b*d*i - a*f*h
    
    Parameters
    ----------
    a : (M, M) array_like
        A square matrix.
    overwrite_a : bool, optional
        Allow overwriting data in a (may enhance performance).
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    det : float or complex
        Determinant of `a`.
    
    Notes
    -----
    The determinant is computed via LU factorization, LAPACK routine z/dgetrf.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.array([[1,2,3], [4,5,6], [7,8,9]])
    >>> linalg.det(a)
    0.0
    >>> a = np.array([[0,2,3], [4,5,6], [7,8,9]])
    >>> linalg.det(a)
    3.0
",function,"('a', 'overwrite_a', 'check_finite')","(nan, False, True)","(nan, 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info')","('(a, overwrite_a=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.dft,linalg,dft,"Python Library Documentation: function dft in module scipy.linalg.special_matrices

dft(n, scale=None)
    Discrete Fourier transform matrix.
    
    Create the matrix that computes the discrete Fourier transform of a
    sequence [1]_.  The n-th primitive root of unity used to generate the
    matrix is exp(-2*pi*i/n), where i = sqrt(-1).
    
    Parameters
    ----------
    n : int
        Size the matrix to create.
    scale : str, optional
        Must be None, 'sqrtn', or 'n'.
        If `scale` is 'sqrtn', the matrix is divided by `sqrt(n)`.
        If `scale` is 'n', the matrix is divided by `n`.
        If `scale` is None (the default), the matrix is not normalized, and the
        return value is simply the Vandermonde matrix of the roots of unity.
    
    Returns
    -------
    m : (n, n) ndarray
        The DFT matrix.
    
    Notes
    -----
    When `scale` is None, multiplying a vector by the matrix returned by
    `dft` is mathematically equivalent to (but much less efficient than)
    the calculation performed by `scipy.fftpack.fft`.
    
    .. versionadded:: 0.14.0
    
    References
    ----------
    .. [1] ""DFT matrix"", http://en.wikipedia.org/wiki/DFT_matrix
    
    Examples
    --------
    >>> from scipy.linalg import dft
    >>> np.set_printoptions(precision=5, suppress=True)
    >>> x = np.array([1, 2, 3, 0, 3, 2, 1, 0])
    >>> m = dft(8)
    >>> m.dot(x)   # Compute the DFT of x
    array([ 12.+0.j,  -2.-2.j,   0.-4.j,  -2.+2.j,   4.+0.j,  -2.-2.j,
            -0.+4.j,  -2.+2.j])
    
    Verify that ``m.dot(x)`` is the same as ``fft(x)``.
    
    >>> from scipy.fftpack import fft
    >>> fft(x)     # Same result as m.dot(x)
    array([ 12.+0.j,  -2.-2.j,   0.-4.j,  -2.+2.j,   4.+0.j,  -2.-2.j,
             0.+4.j,  -2.+2.j])
",function,"('(n, scale=None)',)",scipy,1.1.0,scipy.linalg.dft,linalg,dft,"Python Library Documentation: function dft in module scipy.linalg.special_matrices

dft(n, scale=None)
    Discrete Fourier transform matrix.
    
    Create the matrix that computes the discrete Fourier transform of a
    sequence [1]_.  The n-th primitive root of unity used to generate the
    matrix is exp(-2*pi*i/n), where i = sqrt(-1).
    
    Parameters
    ----------
    n : int
        Size the matrix to create.
    scale : str, optional
        Must be None, 'sqrtn', or 'n'.
        If `scale` is 'sqrtn', the matrix is divided by `sqrt(n)`.
        If `scale` is 'n', the matrix is divided by `n`.
        If `scale` is None (the default), the matrix is not normalized, and the
        return value is simply the Vandermonde matrix of the roots of unity.
    
    Returns
    -------
    m : (n, n) ndarray
        The DFT matrix.
    
    Notes
    -----
    When `scale` is None, multiplying a vector by the matrix returned by
    `dft` is mathematically equivalent to (but much less efficient than)
    the calculation performed by `scipy.fftpack.fft`.
    
    .. versionadded:: 0.14.0
    
    References
    ----------
    .. [1] ""DFT matrix"", http://en.wikipedia.org/wiki/DFT_matrix
    
    Examples
    --------
    >>> from scipy.linalg import dft
    >>> np.set_printoptions(precision=5, suppress=True)
    >>> x = np.array([1, 2, 3, 0, 3, 2, 1, 0])
    >>> m = dft(8)
    >>> m.dot(x)   # Compute the DFT of x
    array([ 12.+0.j,  -2.-2.j,   0.-4.j,  -2.+2.j,   4.+0.j,  -2.-2.j,
            -0.+4.j,  -2.+2.j])
    
    Verify that ``m.dot(x)`` is the same as ``fft(x)``.
    
    >>> from scipy.fftpack import fft
    >>> fft(x)     # Same result as m.dot(x)
    array([ 12.+0.j,  -2.-2.j,   0.-4.j,  -2.+2.j,   4.+0.j,  -2.-2.j,
             0.+4.j,  -2.+2.j])
",function,"('n', 'scale')","(nan, None)","(nan, 'NoneType')","('arg_info', 'arg_info')","('(n, scale=None)',)"
scipy,1.1.0,scipy.linalg.diagsvd,linalg,diagsvd,"Python Library Documentation: function diagsvd in module scipy.linalg.decomp_svd

diagsvd(s, M, N)
    Construct the sigma matrix in SVD from singular values and size M, N.
    
    Parameters
    ----------
    s : (M,) or (N,) array_like
        Singular values
    M : int
        Size of the matrix whose singular values are `s`.
    N : int
        Size of the matrix whose singular values are `s`.
    
    Returns
    -------
    S : (M, N) ndarray
        The S-matrix in the singular value decomposition
    
    See Also
    --------
    svd : Singular value decomposition of a matrix
    svdvals : Compute singular values of a matrix.
    
    Examples
    --------
    >>> from scipy.linalg import diagsvd
    >>> vals = np.array([1, 2, 3])  # The array representing the computed svd
    >>> diagsvd(vals, 3, 4)
    array([[1, 0, 0, 0],
           [0, 2, 0, 0],
           [0, 0, 3, 0]])
    >>> diagsvd(vals, 4, 3)
    array([[1, 0, 0],
           [0, 2, 0],
           [0, 0, 3],
           [0, 0, 0]])
",function,"('(s, M, N)',)",scipy,1.1.0,scipy.linalg.diagsvd,linalg,diagsvd,"Python Library Documentation: function diagsvd in module scipy.linalg.decomp_svd

diagsvd(s, M, N)
    Construct the sigma matrix in SVD from singular values and size M, N.
    
    Parameters
    ----------
    s : (M,) or (N,) array_like
        Singular values
    M : int
        Size of the matrix whose singular values are `s`.
    N : int
        Size of the matrix whose singular values are `s`.
    
    Returns
    -------
    S : (M, N) ndarray
        The S-matrix in the singular value decomposition
    
    See Also
    --------
    svd : Singular value decomposition of a matrix
    svdvals : Compute singular values of a matrix.
    
    Examples
    --------
    >>> from scipy.linalg import diagsvd
    >>> vals = np.array([1, 2, 3])  # The array representing the computed svd
    >>> diagsvd(vals, 3, 4)
    array([[1, 0, 0, 0],
           [0, 2, 0, 0],
           [0, 0, 3, 0]])
    >>> diagsvd(vals, 4, 3)
    array([[1, 0, 0],
           [0, 2, 0],
           [0, 0, 3],
           [0, 0, 0]])
",function,"('s', 'M', 'N')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(s, M, N)',)"
scipy,1.1.0,scipy.linalg.eig,linalg,eig,"Python Library Documentation: function eig in module scipy.linalg.decomp

eig(a, b=None, left=False, right=True, overwrite_a=False, overwrite_b=False, check_finite=True, homogeneous_eigvals=False)
    Solve an ordinary or generalized eigenvalue problem of a square matrix.
    
    Find eigenvalues w and right or left eigenvectors of a general matrix::
    
        a   vr[:,i] = w[i]        b   vr[:,i]
        a.H vl[:,i] = w[i].conj() b.H vl[:,i]
    
    where ``.H`` is the Hermitian conjugation.
    
    Parameters
    ----------
    a : (M, M) array_like
        A complex or real matrix whose eigenvalues and eigenvectors
        will be computed.
    b : (M, M) array_like, optional
        Right-hand side matrix in a generalized eigenvalue problem.
        Default is None, identity matrix is assumed.
    left : bool, optional
        Whether to calculate and return left eigenvectors.  Default is False.
    right : bool, optional
        Whether to calculate and return right eigenvectors.  Default is True.
    overwrite_a : bool, optional
        Whether to overwrite `a`; may improve performance.  Default is False.
    overwrite_b : bool, optional
        Whether to overwrite `b`; may improve performance.  Default is False.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    homogeneous_eigvals : bool, optional
        If True, return the eigenvalues in homogeneous coordinates.
        In this case ``w`` is a (2, M) array so that::
    
            w[1,i] a vr[:,i] = w[0,i] b vr[:,i]
    
        Default is False.
    
    Returns
    -------
    w : (M,) or (2, M) double or complex ndarray
        The eigenvalues, each repeated according to its
        multiplicity. The shape is (M,) unless
        ``homogeneous_eigvals=True``.
    vl : (M, M) double or complex ndarray
        The normalized left eigenvector corresponding to the eigenvalue
        ``w[i]`` is the column vl[:,i]. Only returned if ``left=True``.
    vr : (M, M) double or complex ndarray
        The normalized right eigenvector corresponding to the eigenvalue
        ``w[i]`` is the column ``vr[:,i]``.  Only returned if ``right=True``.
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge.
    
    See Also
    --------
    eigvals : eigenvalues of general arrays
    eigh : Eigenvalues and right eigenvectors for symmetric/Hermitian arrays.
    eig_banded : eigenvalues and right eigenvectors for symmetric/Hermitian
        band matrices
    eigh_tridiagonal : eigenvalues and right eiegenvectors for
        symmetric/Hermitian tridiagonal matrices
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.array([[0., -1.], [1., 0.]])
    >>> linalg.eigvals(a)
    array([0.+1.j, 0.-1.j])
    
    >>> b = np.array([[0., 1.], [1., 1.]])
    >>> linalg.eigvals(a, b)
    array([ 1.+0.j, -1.+0.j])
    
    >>> a = np.array([[3., 0., 0.], [0., 8., 0.], [0., 0., 7.]])
    >>> linalg.eigvals(a, homogeneous_eigvals=True)
    array([[3.+0.j, 8.+0.j, 7.+0.j],
           [1.+0.j, 1.+0.j, 1.+0.j]])
    
    >>> a = np.array([[0., -1.], [1., 0.]])
    >>> linalg.eigvals(a) == linalg.eig(a)[0]
    array([ True,  True])
    >>> linalg.eig(a, left=True, right=False)[1] # normalized left eigenvector
    array([[-0.70710678+0.j        , -0.70710678-0.j        ],
           [-0.        +0.70710678j, -0.        -0.70710678j]])
    >>> linalg.eig(a, left=False, right=True)[1] # normalized right eigenvector
    array([[0.70710678+0.j        , 0.70710678-0.j        ],
           [0.        -0.70710678j, 0.        +0.70710678j]])
",function,"('(a, b=None, left=False, right=True, overwrite_a=False, overwrite_b=False, check_finite=True, homogeneous_eigvals=False)',)",scipy,1.1.0,scipy.linalg.eig,linalg,eig,"Python Library Documentation: function eig in module scipy.linalg.decomp

eig(a, b=None, left=False, right=True, overwrite_a=False, overwrite_b=False, check_finite=True, homogeneous_eigvals=False)
    Solve an ordinary or generalized eigenvalue problem of a square matrix.
    
    Find eigenvalues w and right or left eigenvectors of a general matrix::
    
        a   vr[:,i] = w[i]        b   vr[:,i]
        a.H vl[:,i] = w[i].conj() b.H vl[:,i]
    
    where ``.H`` is the Hermitian conjugation.
    
    Parameters
    ----------
    a : (M, M) array_like
        A complex or real matrix whose eigenvalues and eigenvectors
        will be computed.
    b : (M, M) array_like, optional
        Right-hand side matrix in a generalized eigenvalue problem.
        Default is None, identity matrix is assumed.
    left : bool, optional
        Whether to calculate and return left eigenvectors.  Default is False.
    right : bool, optional
        Whether to calculate and return right eigenvectors.  Default is True.
    overwrite_a : bool, optional
        Whether to overwrite `a`; may improve performance.  Default is False.
    overwrite_b : bool, optional
        Whether to overwrite `b`; may improve performance.  Default is False.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    homogeneous_eigvals : bool, optional
        If True, return the eigenvalues in homogeneous coordinates.
        In this case ``w`` is a (2, M) array so that::
    
            w[1,i] a vr[:,i] = w[0,i] b vr[:,i]
    
        Default is False.
    
    Returns
    -------
    w : (M,) or (2, M) double or complex ndarray
        The eigenvalues, each repeated according to its
        multiplicity. The shape is (M,) unless
        ``homogeneous_eigvals=True``.
    vl : (M, M) double or complex ndarray
        The normalized left eigenvector corresponding to the eigenvalue
        ``w[i]`` is the column vl[:,i]. Only returned if ``left=True``.
    vr : (M, M) double or complex ndarray
        The normalized right eigenvector corresponding to the eigenvalue
        ``w[i]`` is the column ``vr[:,i]``.  Only returned if ``right=True``.
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge.
    
    See Also
    --------
    eigvals : eigenvalues of general arrays
    eigh : Eigenvalues and right eigenvectors for symmetric/Hermitian arrays.
    eig_banded : eigenvalues and right eigenvectors for symmetric/Hermitian
        band matrices
    eigh_tridiagonal : eigenvalues and right eiegenvectors for
        symmetric/Hermitian tridiagonal matrices
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.array([[0., -1.], [1., 0.]])
    >>> linalg.eigvals(a)
    array([0.+1.j, 0.-1.j])
    
    >>> b = np.array([[0., 1.], [1., 1.]])
    >>> linalg.eigvals(a, b)
    array([ 1.+0.j, -1.+0.j])
    
    >>> a = np.array([[3., 0., 0.], [0., 8., 0.], [0., 0., 7.]])
    >>> linalg.eigvals(a, homogeneous_eigvals=True)
    array([[3.+0.j, 8.+0.j, 7.+0.j],
           [1.+0.j, 1.+0.j, 1.+0.j]])
    
    >>> a = np.array([[0., -1.], [1., 0.]])
    >>> linalg.eigvals(a) == linalg.eig(a)[0]
    array([ True,  True])
    >>> linalg.eig(a, left=True, right=False)[1] # normalized left eigenvector
    array([[-0.70710678+0.j        , -0.70710678-0.j        ],
           [-0.        +0.70710678j, -0.        -0.70710678j]])
    >>> linalg.eig(a, left=False, right=True)[1] # normalized right eigenvector
    array([[0.70710678+0.j        , 0.70710678-0.j        ],
           [0.        -0.70710678j, 0.        +0.70710678j]])
",function,"('a', 'b', 'left', 'right', 'overwrite_a', 'overwrite_b', 'check_finite', 'homogeneous_eigvals')","(nan, None, False, True, False, False, True, False)","(nan, 'NoneType', 'bool', 'bool', 'bool', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, b=None, left=False, right=True, overwrite_a=False, overwrite_b=False, check_finite=True, homogeneous_eigvals=False)',)"
scipy,1.1.0,scipy.linalg.eig_banded,linalg,eig_banded,"Python Library Documentation: function eig_banded in module scipy.linalg.decomp

eig_banded(a_band, lower=False, eigvals_only=False, overwrite_a_band=False, select='a', select_range=None, max_ev=0, check_finite=True)
    Solve real symmetric or complex hermitian band matrix eigenvalue problem.
    
    Find eigenvalues w and optionally right eigenvectors v of a::
    
        a v[:,i] = w[i] v[:,i]
        v.H v    = identity
    
    The matrix a is stored in a_band either in lower diagonal or upper
    diagonal ordered form:
    
        a_band[u + i - j, j] == a[i,j]        (if upper form; i <= j)
        a_band[    i - j, j] == a[i,j]        (if lower form; i >= j)
    
    where u is the number of bands above the diagonal.
    
    Example of a_band (shape of a is (6,6), u=2)::
    
        upper form:
        *   *   a02 a13 a24 a35
        *   a01 a12 a23 a34 a45
        a00 a11 a22 a33 a44 a55
    
        lower form:
        a00 a11 a22 a33 a44 a55
        a10 a21 a32 a43 a54 *
        a20 a31 a42 a53 *   *
    
    Cells marked with * are not used.
    
    Parameters
    ----------
    a_band : (u+1, M) array_like
        The bands of the M by M matrix a.
    lower : bool, optional
        Is the matrix in the lower form. (Default is upper form)
    eigvals_only : bool, optional
        Compute only the eigenvalues and no eigenvectors.
        (Default: calculate also eigenvectors)
    overwrite_a_band : bool, optional
        Discard data in a_band (may enhance performance)
    select : {'a', 'v', 'i'}, optional
        Which eigenvalues to calculate
    
        ======  ========================================
        select  calculated
        ======  ========================================
        'a'     All eigenvalues
        'v'     Eigenvalues in the interval (min, max]
        'i'     Eigenvalues with indices min <= i <= max
        ======  ========================================
    select_range : (min, max), optional
        Range of selected eigenvalues
    max_ev : int, optional
        For select=='v', maximum number of eigenvalues expected.
        For other values of select, has no meaning.
    
        In doubt, leave this parameter untouched.
    
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    w : (M,) ndarray
        The eigenvalues, in ascending order, each repeated according to its
        multiplicity.
    v : (M, M) float or complex ndarray
        The normalized eigenvector corresponding to the eigenvalue w[i] is
        the column v[:,i].
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge.
    
    See Also
    --------
    eigvals_banded : eigenvalues for symmetric/Hermitian band matrices
    eig : eigenvalues and right eigenvectors of general arrays.
    eigh : eigenvalues and right eigenvectors for symmetric/Hermitian arrays
    eigh_tridiagonal : eigenvalues and right eiegenvectors for
        symmetric/Hermitian tridiagonal matrices
    
    Examples
    --------
    >>> from scipy.linalg import eig_banded
    >>> A = np.array([[1, 5, 2, 0], [5, 2, 5, 2], [2, 5, 3, 5], [0, 2, 5, 4]])
    >>> Ab = np.array([[1, 2, 3, 4], [5, 5, 5, 0], [2, 2, 0, 0]])
    >>> w, v = eig_banded(Ab, lower=True)
    >>> np.allclose(A @ v - v @ np.diag(w), np.zeros((4, 4)))
    True
    >>> w = eig_banded(Ab, lower=True, eigvals_only=True)
    >>> w
    array([-4.26200532, -2.22987175,  3.95222349, 12.53965359])
    
    Request only the eigenvalues between ``[-3, 4]``
    
    >>> w, v = eig_banded(Ab, lower=True, select='v', select_range=[-3, 4])
    >>> w
    array([-2.22987175,  3.95222349])
",function,"(""(a_band, lower=False, eigvals_only=False, overwrite_a_band=False, select='a', select_range=None, max_ev=0, check_finite=True)"",)",scipy,1.1.0,scipy.linalg.eig_banded,linalg,eig_banded,"Python Library Documentation: function eig_banded in module scipy.linalg.decomp

eig_banded(a_band, lower=False, eigvals_only=False, overwrite_a_band=False, select='a', select_range=None, max_ev=0, check_finite=True)
    Solve real symmetric or complex hermitian band matrix eigenvalue problem.
    
    Find eigenvalues w and optionally right eigenvectors v of a::
    
        a v[:,i] = w[i] v[:,i]
        v.H v    = identity
    
    The matrix a is stored in a_band either in lower diagonal or upper
    diagonal ordered form:
    
        a_band[u + i - j, j] == a[i,j]        (if upper form; i <= j)
        a_band[    i - j, j] == a[i,j]        (if lower form; i >= j)
    
    where u is the number of bands above the diagonal.
    
    Example of a_band (shape of a is (6,6), u=2)::
    
        upper form:
        *   *   a02 a13 a24 a35
        *   a01 a12 a23 a34 a45
        a00 a11 a22 a33 a44 a55
    
        lower form:
        a00 a11 a22 a33 a44 a55
        a10 a21 a32 a43 a54 *
        a20 a31 a42 a53 *   *
    
    Cells marked with * are not used.
    
    Parameters
    ----------
    a_band : (u+1, M) array_like
        The bands of the M by M matrix a.
    lower : bool, optional
        Is the matrix in the lower form. (Default is upper form)
    eigvals_only : bool, optional
        Compute only the eigenvalues and no eigenvectors.
        (Default: calculate also eigenvectors)
    overwrite_a_band : bool, optional
        Discard data in a_band (may enhance performance)
    select : {'a', 'v', 'i'}, optional
        Which eigenvalues to calculate
    
        ======  ========================================
        select  calculated
        ======  ========================================
        'a'     All eigenvalues
        'v'     Eigenvalues in the interval (min, max]
        'i'     Eigenvalues with indices min <= i <= max
        ======  ========================================
    select_range : (min, max), optional
        Range of selected eigenvalues
    max_ev : int, optional
        For select=='v', maximum number of eigenvalues expected.
        For other values of select, has no meaning.
    
        In doubt, leave this parameter untouched.
    
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    w : (M,) ndarray
        The eigenvalues, in ascending order, each repeated according to its
        multiplicity.
    v : (M, M) float or complex ndarray
        The normalized eigenvector corresponding to the eigenvalue w[i] is
        the column v[:,i].
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge.
    
    See Also
    --------
    eigvals_banded : eigenvalues for symmetric/Hermitian band matrices
    eig : eigenvalues and right eigenvectors of general arrays.
    eigh : eigenvalues and right eigenvectors for symmetric/Hermitian arrays
    eigh_tridiagonal : eigenvalues and right eiegenvectors for
        symmetric/Hermitian tridiagonal matrices
    
    Examples
    --------
    >>> from scipy.linalg import eig_banded
    >>> A = np.array([[1, 5, 2, 0], [5, 2, 5, 2], [2, 5, 3, 5], [0, 2, 5, 4]])
    >>> Ab = np.array([[1, 2, 3, 4], [5, 5, 5, 0], [2, 2, 0, 0]])
    >>> w, v = eig_banded(Ab, lower=True)
    >>> np.allclose(A @ v - v @ np.diag(w), np.zeros((4, 4)))
    True
    >>> w = eig_banded(Ab, lower=True, eigvals_only=True)
    >>> w
    array([-4.26200532, -2.22987175,  3.95222349, 12.53965359])
    
    Request only the eigenvalues between ``[-3, 4]``
    
    >>> w, v = eig_banded(Ab, lower=True, select='v', select_range=[-3, 4])
    >>> w
    array([-2.22987175,  3.95222349])
",function,"('a_band', 'lower', 'eigvals_only', 'overwrite_a_band', 'select', 'select_range', 'max_ev', 'check_finite')","(nan, False, False, False, 'a', None, 0, True)","(nan, 'bool', 'bool', 'bool', 'str', 'NoneType', 'int', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a_band, lower=False, eigvals_only=False, overwrite_a_band=False, select='a', select_range=None, max_ev=0, check_finite=True)"",)"
scipy,1.1.0,scipy.linalg.eigh,linalg,eigh,"Python Library Documentation: function eigh in module scipy.linalg.decomp

eigh(a, b=None, lower=True, eigvals_only=False, overwrite_a=False, overwrite_b=False, turbo=True, eigvals=None, type=1, check_finite=True)
    Solve an ordinary or generalized eigenvalue problem for a complex
    Hermitian or real symmetric matrix.
    
    Find eigenvalues w and optionally eigenvectors v of matrix `a`, where
    `b` is positive definite::
    
                      a v[:,i] = w[i] b v[:,i]
        v[i,:].conj() a v[:,i] = w[i]
        v[i,:].conj() b v[:,i] = 1
    
    Parameters
    ----------
    a : (M, M) array_like
        A complex Hermitian or real symmetric matrix whose eigenvalues and
        eigenvectors will be computed.
    b : (M, M) array_like, optional
        A complex Hermitian or real symmetric definite positive matrix in.
        If omitted, identity matrix is assumed.
    lower : bool, optional
        Whether the pertinent array data is taken from the lower or upper
        triangle of `a`. (Default: lower)
    eigvals_only : bool, optional
        Whether to calculate only eigenvalues and no eigenvectors.
        (Default: both are calculated)
    turbo : bool, optional
        Use divide and conquer algorithm (faster but expensive in memory,
        only for generalized eigenvalue problem and if eigvals=None)
    eigvals : tuple (lo, hi), optional
        Indexes of the smallest and largest (in ascending order) eigenvalues
        and corresponding eigenvectors to be returned: 0 <= lo <= hi <= M-1.
        If omitted, all eigenvalues and eigenvectors are returned.
    type : int, optional
        Specifies the problem type to be solved:
    
           type = 1: a   v[:,i] = w[i] b v[:,i]
    
           type = 2: a b v[:,i] = w[i]   v[:,i]
    
           type = 3: b a v[:,i] = w[i]   v[:,i]
    overwrite_a : bool, optional
        Whether to overwrite data in `a` (may improve performance)
    overwrite_b : bool, optional
        Whether to overwrite data in `b` (may improve performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    w : (N,) float ndarray
        The N (1<=N<=M) selected eigenvalues, in ascending order, each
        repeated according to its multiplicity.
    v : (M, N) complex ndarray
        (if eigvals_only == False)
    
        The normalized selected eigenvector corresponding to the
        eigenvalue w[i] is the column v[:,i].
    
        Normalization:
    
            type 1 and 3: v.conj() a      v  = w
    
            type 2: inv(v).conj() a  inv(v) = w
    
            type = 1 or 2: v.conj() b      v  = I
    
            type = 3: v.conj() inv(b) v  = I
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge,
        an error occurred, or b matrix is not definite positive. Note that
        if input matrices are not symmetric or hermitian, no error is reported
        but results will be wrong.
    
    See Also
    --------
    eigvalsh : eigenvalues of symmetric or Hermitian arrays
    eig : eigenvalues and right eigenvectors for non-symmetric arrays
    eigh : eigenvalues and right eigenvectors for symmetric/Hermitian arrays
    eigh_tridiagonal : eigenvalues and right eiegenvectors for
        symmetric/Hermitian tridiagonal matrices
    
    Notes
    -----
    This function does not check the input array for being hermitian/symmetric
    in order to allow for representing arrays with only their upper/lower
    triangular parts.
    
    Examples
    --------
    >>> from scipy.linalg import eigh
    >>> A = np.array([[6, 3, 1, 5], [3, 0, 5, 1], [1, 5, 6, 2], [5, 1, 2, 2]])
    >>> w, v = eigh(A)
    >>> np.allclose(A @ v - v @ np.diag(w), np.zeros((4, 4)))
    True
",function,"('(a, b=None, lower=True, eigvals_only=False, overwrite_a=False, overwrite_b=False, turbo=True, eigvals=None, type=1, check_finite=True)',)",scipy,1.1.0,scipy.linalg.eigh,linalg,eigh,"Python Library Documentation: function eigh in module scipy.linalg.decomp

eigh(a, b=None, lower=True, eigvals_only=False, overwrite_a=False, overwrite_b=False, turbo=True, eigvals=None, type=1, check_finite=True)
    Solve an ordinary or generalized eigenvalue problem for a complex
    Hermitian or real symmetric matrix.
    
    Find eigenvalues w and optionally eigenvectors v of matrix `a`, where
    `b` is positive definite::
    
                      a v[:,i] = w[i] b v[:,i]
        v[i,:].conj() a v[:,i] = w[i]
        v[i,:].conj() b v[:,i] = 1
    
    Parameters
    ----------
    a : (M, M) array_like
        A complex Hermitian or real symmetric matrix whose eigenvalues and
        eigenvectors will be computed.
    b : (M, M) array_like, optional
        A complex Hermitian or real symmetric definite positive matrix in.
        If omitted, identity matrix is assumed.
    lower : bool, optional
        Whether the pertinent array data is taken from the lower or upper
        triangle of `a`. (Default: lower)
    eigvals_only : bool, optional
        Whether to calculate only eigenvalues and no eigenvectors.
        (Default: both are calculated)
    turbo : bool, optional
        Use divide and conquer algorithm (faster but expensive in memory,
        only for generalized eigenvalue problem and if eigvals=None)
    eigvals : tuple (lo, hi), optional
        Indexes of the smallest and largest (in ascending order) eigenvalues
        and corresponding eigenvectors to be returned: 0 <= lo <= hi <= M-1.
        If omitted, all eigenvalues and eigenvectors are returned.
    type : int, optional
        Specifies the problem type to be solved:
    
           type = 1: a   v[:,i] = w[i] b v[:,i]
    
           type = 2: a b v[:,i] = w[i]   v[:,i]
    
           type = 3: b a v[:,i] = w[i]   v[:,i]
    overwrite_a : bool, optional
        Whether to overwrite data in `a` (may improve performance)
    overwrite_b : bool, optional
        Whether to overwrite data in `b` (may improve performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    w : (N,) float ndarray
        The N (1<=N<=M) selected eigenvalues, in ascending order, each
        repeated according to its multiplicity.
    v : (M, N) complex ndarray
        (if eigvals_only == False)
    
        The normalized selected eigenvector corresponding to the
        eigenvalue w[i] is the column v[:,i].
    
        Normalization:
    
            type 1 and 3: v.conj() a      v  = w
    
            type 2: inv(v).conj() a  inv(v) = w
    
            type = 1 or 2: v.conj() b      v  = I
    
            type = 3: v.conj() inv(b) v  = I
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge,
        an error occurred, or b matrix is not definite positive. Note that
        if input matrices are not symmetric or hermitian, no error is reported
        but results will be wrong.
    
    See Also
    --------
    eigvalsh : eigenvalues of symmetric or Hermitian arrays
    eig : eigenvalues and right eigenvectors for non-symmetric arrays
    eigh : eigenvalues and right eigenvectors for symmetric/Hermitian arrays
    eigh_tridiagonal : eigenvalues and right eiegenvectors for
        symmetric/Hermitian tridiagonal matrices
    
    Notes
    -----
    This function does not check the input array for being hermitian/symmetric
    in order to allow for representing arrays with only their upper/lower
    triangular parts.
    
    Examples
    --------
    >>> from scipy.linalg import eigh
    >>> A = np.array([[6, 3, 1, 5], [3, 0, 5, 1], [1, 5, 6, 2], [5, 1, 2, 2]])
    >>> w, v = eigh(A)
    >>> np.allclose(A @ v - v @ np.diag(w), np.zeros((4, 4)))
    True
",function,"('a', 'b', 'lower', 'eigvals_only', 'overwrite_a', 'overwrite_b', 'turbo', 'eigvals', 'type', 'check_finite')","(nan, None, True, False, False, False, True, None, 1, True)","(nan, 'NoneType', 'bool', 'bool', 'bool', 'bool', 'bool', 'NoneType', 'int', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, b=None, lower=True, eigvals_only=False, overwrite_a=False, overwrite_b=False, turbo=True, eigvals=None, type=1, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.eigh_tridiagonal,linalg,eigh_tridiagonal,"Python Library Documentation: function eigh_tridiagonal in module scipy.linalg.decomp

eigh_tridiagonal(d, e, eigvals_only=False, select='a', select_range=None, check_finite=True, tol=0.0, lapack_driver='auto')
    Solve eigenvalue problem for a real symmetric tridiagonal matrix.
    
    Find eigenvalues `w` and optionally right eigenvectors `v` of ``a``::
    
        a v[:,i] = w[i] v[:,i]
        v.H v    = identity
    
    For a real symmetric matrix ``a`` with diagonal elements `d` and
    off-diagonal elements `e`.
    
    Parameters
    ----------
    d : ndarray, shape (ndim,)
        The diagonal elements of the array.
    e : ndarray, shape (ndim-1,)
        The off-diagonal elements of the array.
    select : {'a', 'v', 'i'}, optional
        Which eigenvalues to calculate
    
        ======  ========================================
        select  calculated
        ======  ========================================
        'a'     All eigenvalues
        'v'     Eigenvalues in the interval (min, max]
        'i'     Eigenvalues with indices min <= i <= max
        ======  ========================================
    select_range : (min, max), optional
        Range of selected eigenvalues
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    tol : float
        The absolute tolerance to which each eigenvalue is required
        (only used when 'stebz' is the `lapack_driver`).
        An eigenvalue (or cluster) is considered to have converged if it
        lies in an interval of this width. If <= 0. (default),
        the value ``eps*|a|`` is used where eps is the machine precision,
        and ``|a|`` is the 1-norm of the matrix ``a``.
    lapack_driver : str
        LAPACK function to use, can be 'auto', 'stemr', 'stebz', 'sterf',
        or 'stev'. When 'auto' (default), it will use 'stemr' if ``select='a'``
        and 'stebz' otherwise. When 'stebz' is used to find the eigenvalues and
        ``eigvals_only=False``, then a second LAPACK call (to ``?STEIN``) is
        used to find the corresponding eigenvectors. 'sterf' can only be
        used when ``eigvals_only=True`` and ``select='a'``. 'stev' can only
        be used when ``select='a'``.
    
    Returns
    -------
    w : (M,) ndarray
        The eigenvalues, in ascending order, each repeated according to its
        multiplicity.
    v : (M, M) ndarray
        The normalized eigenvector corresponding to the eigenvalue ``w[i]`` is
        the column ``v[:,i]``.
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge.
    
    See Also
    --------
    eigvalsh_tridiagonal : eigenvalues of symmetric/Hermitian tridiagonal
        matrices
    eig : eigenvalues and right eigenvectors for non-symmetric arrays
    eigh : eigenvalues and right eigenvectors for symmetric/Hermitian arrays
    eig_banded : eigenvalues and right eigenvectors for symmetric/Hermitian
        band matrices
    
    Notes
    -----
    This function makes use of LAPACK ``S/DSTEMR`` routines.
    
    Examples
    --------
    >>> from scipy.linalg import eigh_tridiagonal
    >>> d = 3*np.ones(4)
    >>> e = -1*np.ones(3)
    >>> w, v = eigh_tridiagonal(d, e)
    >>> A = np.diag(d) + np.diag(e, k=1) + np.diag(e, k=-1)
    >>> np.allclose(A @ v - v @ np.diag(w), np.zeros((4, 4)))
    True
",function,"(""(d, e, eigvals_only=False, select='a', select_range=None, check_finite=True, tol=0.0, lapack_driver='auto')"",)",scipy,1.1.0,scipy.linalg.eigh_tridiagonal,linalg,eigh_tridiagonal,"Python Library Documentation: function eigh_tridiagonal in module scipy.linalg.decomp

eigh_tridiagonal(d, e, eigvals_only=False, select='a', select_range=None, check_finite=True, tol=0.0, lapack_driver='auto')
    Solve eigenvalue problem for a real symmetric tridiagonal matrix.
    
    Find eigenvalues `w` and optionally right eigenvectors `v` of ``a``::
    
        a v[:,i] = w[i] v[:,i]
        v.H v    = identity
    
    For a real symmetric matrix ``a`` with diagonal elements `d` and
    off-diagonal elements `e`.
    
    Parameters
    ----------
    d : ndarray, shape (ndim,)
        The diagonal elements of the array.
    e : ndarray, shape (ndim-1,)
        The off-diagonal elements of the array.
    select : {'a', 'v', 'i'}, optional
        Which eigenvalues to calculate
    
        ======  ========================================
        select  calculated
        ======  ========================================
        'a'     All eigenvalues
        'v'     Eigenvalues in the interval (min, max]
        'i'     Eigenvalues with indices min <= i <= max
        ======  ========================================
    select_range : (min, max), optional
        Range of selected eigenvalues
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    tol : float
        The absolute tolerance to which each eigenvalue is required
        (only used when 'stebz' is the `lapack_driver`).
        An eigenvalue (or cluster) is considered to have converged if it
        lies in an interval of this width. If <= 0. (default),
        the value ``eps*|a|`` is used where eps is the machine precision,
        and ``|a|`` is the 1-norm of the matrix ``a``.
    lapack_driver : str
        LAPACK function to use, can be 'auto', 'stemr', 'stebz', 'sterf',
        or 'stev'. When 'auto' (default), it will use 'stemr' if ``select='a'``
        and 'stebz' otherwise. When 'stebz' is used to find the eigenvalues and
        ``eigvals_only=False``, then a second LAPACK call (to ``?STEIN``) is
        used to find the corresponding eigenvectors. 'sterf' can only be
        used when ``eigvals_only=True`` and ``select='a'``. 'stev' can only
        be used when ``select='a'``.
    
    Returns
    -------
    w : (M,) ndarray
        The eigenvalues, in ascending order, each repeated according to its
        multiplicity.
    v : (M, M) ndarray
        The normalized eigenvector corresponding to the eigenvalue ``w[i]`` is
        the column ``v[:,i]``.
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge.
    
    See Also
    --------
    eigvalsh_tridiagonal : eigenvalues of symmetric/Hermitian tridiagonal
        matrices
    eig : eigenvalues and right eigenvectors for non-symmetric arrays
    eigh : eigenvalues and right eigenvectors for symmetric/Hermitian arrays
    eig_banded : eigenvalues and right eigenvectors for symmetric/Hermitian
        band matrices
    
    Notes
    -----
    This function makes use of LAPACK ``S/DSTEMR`` routines.
    
    Examples
    --------
    >>> from scipy.linalg import eigh_tridiagonal
    >>> d = 3*np.ones(4)
    >>> e = -1*np.ones(3)
    >>> w, v = eigh_tridiagonal(d, e)
    >>> A = np.diag(d) + np.diag(e, k=1) + np.diag(e, k=-1)
    >>> np.allclose(A @ v - v @ np.diag(w), np.zeros((4, 4)))
    True
",function,"('d', 'e', 'eigvals_only', 'select', 'select_range', 'check_finite', 'tol', 'lapack_driver')","(nan, nan, False, 'a', None, True, 0.0, 'auto')","(nan, nan, 'bool', 'str', 'NoneType', 'bool', 'float', 'str')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(d, e, eigvals_only=False, select='a', select_range=None, check_finite=True, tol=0.0, lapack_driver='auto')"",)"
scipy,1.1.0,scipy.linalg.eigvals,linalg,eigvals,"Python Library Documentation: function eigvals in module scipy.linalg.decomp

eigvals(a, b=None, overwrite_a=False, check_finite=True, homogeneous_eigvals=False)
    Compute eigenvalues from an ordinary or generalized eigenvalue problem.
    
    Find eigenvalues of a general matrix::
    
        a   vr[:,i] = w[i]        b   vr[:,i]
    
    Parameters
    ----------
    a : (M, M) array_like
        A complex or real matrix whose eigenvalues and eigenvectors
        will be computed.
    b : (M, M) array_like, optional
        Right-hand side matrix in a generalized eigenvalue problem.
        If omitted, identity matrix is assumed.
    overwrite_a : bool, optional
        Whether to overwrite data in a (may improve performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities
        or NaNs.
    homogeneous_eigvals : bool, optional
        If True, return the eigenvalues in homogeneous coordinates.
        In this case ``w`` is a (2, M) array so that::
    
            w[1,i] a vr[:,i] = w[0,i] b vr[:,i]
    
        Default is False.
    
    Returns
    -------
    w : (M,) or (2, M) double or complex ndarray
        The eigenvalues, each repeated according to its multiplicity
        but not in any specific order. The shape is (M,) unless
        ``homogeneous_eigvals=True``.
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge
    
    See Also
    --------
    eig : eigenvalues and right eigenvectors of general arrays.
    eigvalsh : eigenvalues of symmetric or Hermitian arrays
    eigvals_banded : eigenvalues for symmetric/Hermitian band matrices
    eigvalsh_tridiagonal : eigenvalues of symmetric/Hermitian tridiagonal
        matrices
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.array([[0., -1.], [1., 0.]])
    >>> linalg.eigvals(a)
    array([0.+1.j, 0.-1.j])
    
    >>> b = np.array([[0., 1.], [1., 1.]])
    >>> linalg.eigvals(a, b)
    array([ 1.+0.j, -1.+0.j])
    
    >>> a = np.array([[3., 0., 0.], [0., 8., 0.], [0., 0., 7.]])
    >>> linalg.eigvals(a, homogeneous_eigvals=True)
    array([[3.+0.j, 8.+0.j, 7.+0.j],
           [1.+0.j, 1.+0.j, 1.+0.j]])
",function,"('(a, b=None, overwrite_a=False, check_finite=True, homogeneous_eigvals=False)',)",scipy,1.1.0,scipy.linalg.eigvals,linalg,eigvals,"Python Library Documentation: function eigvals in module scipy.linalg.decomp

eigvals(a, b=None, overwrite_a=False, check_finite=True, homogeneous_eigvals=False)
    Compute eigenvalues from an ordinary or generalized eigenvalue problem.
    
    Find eigenvalues of a general matrix::
    
        a   vr[:,i] = w[i]        b   vr[:,i]
    
    Parameters
    ----------
    a : (M, M) array_like
        A complex or real matrix whose eigenvalues and eigenvectors
        will be computed.
    b : (M, M) array_like, optional
        Right-hand side matrix in a generalized eigenvalue problem.
        If omitted, identity matrix is assumed.
    overwrite_a : bool, optional
        Whether to overwrite data in a (may improve performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities
        or NaNs.
    homogeneous_eigvals : bool, optional
        If True, return the eigenvalues in homogeneous coordinates.
        In this case ``w`` is a (2, M) array so that::
    
            w[1,i] a vr[:,i] = w[0,i] b vr[:,i]
    
        Default is False.
    
    Returns
    -------
    w : (M,) or (2, M) double or complex ndarray
        The eigenvalues, each repeated according to its multiplicity
        but not in any specific order. The shape is (M,) unless
        ``homogeneous_eigvals=True``.
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge
    
    See Also
    --------
    eig : eigenvalues and right eigenvectors of general arrays.
    eigvalsh : eigenvalues of symmetric or Hermitian arrays
    eigvals_banded : eigenvalues for symmetric/Hermitian band matrices
    eigvalsh_tridiagonal : eigenvalues of symmetric/Hermitian tridiagonal
        matrices
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.array([[0., -1.], [1., 0.]])
    >>> linalg.eigvals(a)
    array([0.+1.j, 0.-1.j])
    
    >>> b = np.array([[0., 1.], [1., 1.]])
    >>> linalg.eigvals(a, b)
    array([ 1.+0.j, -1.+0.j])
    
    >>> a = np.array([[3., 0., 0.], [0., 8., 0.], [0., 0., 7.]])
    >>> linalg.eigvals(a, homogeneous_eigvals=True)
    array([[3.+0.j, 8.+0.j, 7.+0.j],
           [1.+0.j, 1.+0.j, 1.+0.j]])
",function,"('a', 'b', 'overwrite_a', 'check_finite', 'homogeneous_eigvals')","(nan, None, False, True, False)","(nan, 'NoneType', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, b=None, overwrite_a=False, check_finite=True, homogeneous_eigvals=False)',)"
scipy,1.1.0,scipy.linalg.eigvals_banded,linalg,eigvals_banded,"Python Library Documentation: function eigvals_banded in module scipy.linalg.decomp

eigvals_banded(a_band, lower=False, overwrite_a_band=False, select='a', select_range=None, check_finite=True)
    Solve real symmetric or complex hermitian band matrix eigenvalue problem.
    
    Find eigenvalues w of a::
    
        a v[:,i] = w[i] v[:,i]
        v.H v    = identity
    
    The matrix a is stored in a_band either in lower diagonal or upper
    diagonal ordered form:
    
        a_band[u + i - j, j] == a[i,j]        (if upper form; i <= j)
        a_band[    i - j, j] == a[i,j]        (if lower form; i >= j)
    
    where u is the number of bands above the diagonal.
    
    Example of a_band (shape of a is (6,6), u=2)::
    
        upper form:
        *   *   a02 a13 a24 a35
        *   a01 a12 a23 a34 a45
        a00 a11 a22 a33 a44 a55
    
        lower form:
        a00 a11 a22 a33 a44 a55
        a10 a21 a32 a43 a54 *
        a20 a31 a42 a53 *   *
    
    Cells marked with * are not used.
    
    Parameters
    ----------
    a_band : (u+1, M) array_like
        The bands of the M by M matrix a.
    lower : bool, optional
        Is the matrix in the lower form. (Default is upper form)
    overwrite_a_band : bool, optional
        Discard data in a_band (may enhance performance)
    select : {'a', 'v', 'i'}, optional
        Which eigenvalues to calculate
    
        ======  ========================================
        select  calculated
        ======  ========================================
        'a'     All eigenvalues
        'v'     Eigenvalues in the interval (min, max]
        'i'     Eigenvalues with indices min <= i <= max
        ======  ========================================
    select_range : (min, max), optional
        Range of selected eigenvalues
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    w : (M,) ndarray
        The eigenvalues, in ascending order, each repeated according to its
        multiplicity.
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge.
    
    See Also
    --------
    eig_banded : eigenvalues and right eigenvectors for symmetric/Hermitian
        band matrices
    eigvalsh_tridiagonal : eigenvalues of symmetric/Hermitian tridiagonal
        matrices
    eigvals : eigenvalues of general arrays
    eigh : eigenvalues and right eigenvectors for symmetric/Hermitian arrays
    eig : eigenvalues and right eigenvectors for non-symmetric arrays
    
    Examples
    --------
    >>> from scipy.linalg import eigvals_banded
    >>> A = np.array([[1, 5, 2, 0], [5, 2, 5, 2], [2, 5, 3, 5], [0, 2, 5, 4]])
    >>> Ab = np.array([[1, 2, 3, 4], [5, 5, 5, 0], [2, 2, 0, 0]])
    >>> w = eigvals_banded(Ab, lower=True)
    >>> w
    array([-4.26200532, -2.22987175,  3.95222349, 12.53965359])
",function,"(""(a_band, lower=False, overwrite_a_band=False, select='a', select_range=None, check_finite=True)"",)",scipy,1.1.0,scipy.linalg.eigvals_banded,linalg,eigvals_banded,"Python Library Documentation: function eigvals_banded in module scipy.linalg.decomp

eigvals_banded(a_band, lower=False, overwrite_a_band=False, select='a', select_range=None, check_finite=True)
    Solve real symmetric or complex hermitian band matrix eigenvalue problem.
    
    Find eigenvalues w of a::
    
        a v[:,i] = w[i] v[:,i]
        v.H v    = identity
    
    The matrix a is stored in a_band either in lower diagonal or upper
    diagonal ordered form:
    
        a_band[u + i - j, j] == a[i,j]        (if upper form; i <= j)
        a_band[    i - j, j] == a[i,j]        (if lower form; i >= j)
    
    where u is the number of bands above the diagonal.
    
    Example of a_band (shape of a is (6,6), u=2)::
    
        upper form:
        *   *   a02 a13 a24 a35
        *   a01 a12 a23 a34 a45
        a00 a11 a22 a33 a44 a55
    
        lower form:
        a00 a11 a22 a33 a44 a55
        a10 a21 a32 a43 a54 *
        a20 a31 a42 a53 *   *
    
    Cells marked with * are not used.
    
    Parameters
    ----------
    a_band : (u+1, M) array_like
        The bands of the M by M matrix a.
    lower : bool, optional
        Is the matrix in the lower form. (Default is upper form)
    overwrite_a_band : bool, optional
        Discard data in a_band (may enhance performance)
    select : {'a', 'v', 'i'}, optional
        Which eigenvalues to calculate
    
        ======  ========================================
        select  calculated
        ======  ========================================
        'a'     All eigenvalues
        'v'     Eigenvalues in the interval (min, max]
        'i'     Eigenvalues with indices min <= i <= max
        ======  ========================================
    select_range : (min, max), optional
        Range of selected eigenvalues
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    w : (M,) ndarray
        The eigenvalues, in ascending order, each repeated according to its
        multiplicity.
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge.
    
    See Also
    --------
    eig_banded : eigenvalues and right eigenvectors for symmetric/Hermitian
        band matrices
    eigvalsh_tridiagonal : eigenvalues of symmetric/Hermitian tridiagonal
        matrices
    eigvals : eigenvalues of general arrays
    eigh : eigenvalues and right eigenvectors for symmetric/Hermitian arrays
    eig : eigenvalues and right eigenvectors for non-symmetric arrays
    
    Examples
    --------
    >>> from scipy.linalg import eigvals_banded
    >>> A = np.array([[1, 5, 2, 0], [5, 2, 5, 2], [2, 5, 3, 5], [0, 2, 5, 4]])
    >>> Ab = np.array([[1, 2, 3, 4], [5, 5, 5, 0], [2, 2, 0, 0]])
    >>> w = eigvals_banded(Ab, lower=True)
    >>> w
    array([-4.26200532, -2.22987175,  3.95222349, 12.53965359])
",function,"('a_band', 'lower', 'overwrite_a_band', 'select', 'select_range', 'check_finite')","(nan, False, False, 'a', None, True)","(nan, 'bool', 'bool', 'str', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a_band, lower=False, overwrite_a_band=False, select='a', select_range=None, check_finite=True)"",)"
scipy,1.1.0,scipy.linalg.eigvalsh,linalg,eigvalsh,"Python Library Documentation: function eigvalsh in module scipy.linalg.decomp

eigvalsh(a, b=None, lower=True, overwrite_a=False, overwrite_b=False, turbo=True, eigvals=None, type=1, check_finite=True)
    Solve an ordinary or generalized eigenvalue problem for a complex
    Hermitian or real symmetric matrix.
    
    Find eigenvalues w of matrix a, where b is positive definite::
    
                      a v[:,i] = w[i] b v[:,i]
        v[i,:].conj() a v[:,i] = w[i]
        v[i,:].conj() b v[:,i] = 1
    
    
    Parameters
    ----------
    a : (M, M) array_like
        A complex Hermitian or real symmetric matrix whose eigenvalues and
        eigenvectors will be computed.
    b : (M, M) array_like, optional
        A complex Hermitian or real symmetric definite positive matrix in.
        If omitted, identity matrix is assumed.
    lower : bool, optional
        Whether the pertinent array data is taken from the lower or upper
        triangle of `a`. (Default: lower)
    turbo : bool, optional
        Use divide and conquer algorithm (faster but expensive in memory,
        only for generalized eigenvalue problem and if eigvals=None)
    eigvals : tuple (lo, hi), optional
        Indexes of the smallest and largest (in ascending order) eigenvalues
        and corresponding eigenvectors to be returned: 0 <= lo < hi <= M-1.
        If omitted, all eigenvalues and eigenvectors are returned.
    type : int, optional
        Specifies the problem type to be solved:
    
           type = 1: a   v[:,i] = w[i] b v[:,i]
    
           type = 2: a b v[:,i] = w[i]   v[:,i]
    
           type = 3: b a v[:,i] = w[i]   v[:,i]
    overwrite_a : bool, optional
        Whether to overwrite data in `a` (may improve performance)
    overwrite_b : bool, optional
        Whether to overwrite data in `b` (may improve performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    w : (N,) float ndarray
        The N (1<=N<=M) selected eigenvalues, in ascending order, each
        repeated according to its multiplicity.
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge,
        an error occurred, or b matrix is not definite positive. Note that
        if input matrices are not symmetric or hermitian, no error is reported
        but results will be wrong.
    
    See Also
    --------
    eigh : eigenvalues and right eigenvectors for symmetric/Hermitian arrays
    eigvals : eigenvalues of general arrays
    eigvals_banded : eigenvalues for symmetric/Hermitian band matrices
    eigvalsh_tridiagonal : eigenvalues of symmetric/Hermitian tridiagonal
        matrices
    
    Notes
    -----
    This function does not check the input array for being hermitian/symmetric
    in order to allow for representing arrays with only their upper/lower
    triangular parts.
    
    Examples
    --------
    >>> from scipy.linalg import eigvalsh
    >>> A = np.array([[6, 3, 1, 5], [3, 0, 5, 1], [1, 5, 6, 2], [5, 1, 2, 2]])
    >>> w = eigvalsh(A)
    >>> w
    array([-3.74637491, -0.76263923,  6.08502336, 12.42399079])
",function,"('(a, b=None, lower=True, overwrite_a=False, overwrite_b=False, turbo=True, eigvals=None, type=1, check_finite=True)',)",scipy,1.1.0,scipy.linalg.eigvalsh,linalg,eigvalsh,"Python Library Documentation: function eigvalsh in module scipy.linalg.decomp

eigvalsh(a, b=None, lower=True, overwrite_a=False, overwrite_b=False, turbo=True, eigvals=None, type=1, check_finite=True)
    Solve an ordinary or generalized eigenvalue problem for a complex
    Hermitian or real symmetric matrix.
    
    Find eigenvalues w of matrix a, where b is positive definite::
    
                      a v[:,i] = w[i] b v[:,i]
        v[i,:].conj() a v[:,i] = w[i]
        v[i,:].conj() b v[:,i] = 1
    
    
    Parameters
    ----------
    a : (M, M) array_like
        A complex Hermitian or real symmetric matrix whose eigenvalues and
        eigenvectors will be computed.
    b : (M, M) array_like, optional
        A complex Hermitian or real symmetric definite positive matrix in.
        If omitted, identity matrix is assumed.
    lower : bool, optional
        Whether the pertinent array data is taken from the lower or upper
        triangle of `a`. (Default: lower)
    turbo : bool, optional
        Use divide and conquer algorithm (faster but expensive in memory,
        only for generalized eigenvalue problem and if eigvals=None)
    eigvals : tuple (lo, hi), optional
        Indexes of the smallest and largest (in ascending order) eigenvalues
        and corresponding eigenvectors to be returned: 0 <= lo < hi <= M-1.
        If omitted, all eigenvalues and eigenvectors are returned.
    type : int, optional
        Specifies the problem type to be solved:
    
           type = 1: a   v[:,i] = w[i] b v[:,i]
    
           type = 2: a b v[:,i] = w[i]   v[:,i]
    
           type = 3: b a v[:,i] = w[i]   v[:,i]
    overwrite_a : bool, optional
        Whether to overwrite data in `a` (may improve performance)
    overwrite_b : bool, optional
        Whether to overwrite data in `b` (may improve performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    w : (N,) float ndarray
        The N (1<=N<=M) selected eigenvalues, in ascending order, each
        repeated according to its multiplicity.
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge,
        an error occurred, or b matrix is not definite positive. Note that
        if input matrices are not symmetric or hermitian, no error is reported
        but results will be wrong.
    
    See Also
    --------
    eigh : eigenvalues and right eigenvectors for symmetric/Hermitian arrays
    eigvals : eigenvalues of general arrays
    eigvals_banded : eigenvalues for symmetric/Hermitian band matrices
    eigvalsh_tridiagonal : eigenvalues of symmetric/Hermitian tridiagonal
        matrices
    
    Notes
    -----
    This function does not check the input array for being hermitian/symmetric
    in order to allow for representing arrays with only their upper/lower
    triangular parts.
    
    Examples
    --------
    >>> from scipy.linalg import eigvalsh
    >>> A = np.array([[6, 3, 1, 5], [3, 0, 5, 1], [1, 5, 6, 2], [5, 1, 2, 2]])
    >>> w = eigvalsh(A)
    >>> w
    array([-3.74637491, -0.76263923,  6.08502336, 12.42399079])
",function,"('a', 'b', 'lower', 'overwrite_a', 'overwrite_b', 'turbo', 'eigvals', 'type', 'check_finite')","(nan, None, True, False, False, True, None, 1, True)","(nan, 'NoneType', 'bool', 'bool', 'bool', 'bool', 'NoneType', 'int', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, b=None, lower=True, overwrite_a=False, overwrite_b=False, turbo=True, eigvals=None, type=1, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.eigvalsh_tridiagonal,linalg,eigvalsh_tridiagonal,"Python Library Documentation: function eigvalsh_tridiagonal in module scipy.linalg.decomp

eigvalsh_tridiagonal(d, e, select='a', select_range=None, check_finite=True, tol=0.0, lapack_driver='auto')
    Solve eigenvalue problem for a real symmetric tridiagonal matrix.
    
    Find eigenvalues `w` of ``a``::
    
        a v[:,i] = w[i] v[:,i]
        v.H v    = identity
    
    For a real symmetric matrix ``a`` with diagonal elements `d` and
    off-diagonal elements `e`.
    
    Parameters
    ----------
    d : ndarray, shape (ndim,)
        The diagonal elements of the array.
    e : ndarray, shape (ndim-1,)
        The off-diagonal elements of the array.
    select : {'a', 'v', 'i'}, optional
        Which eigenvalues to calculate
    
        ======  ========================================
        select  calculated
        ======  ========================================
        'a'     All eigenvalues
        'v'     Eigenvalues in the interval (min, max]
        'i'     Eigenvalues with indices min <= i <= max
        ======  ========================================
    select_range : (min, max), optional
        Range of selected eigenvalues
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    tol : float
        The absolute tolerance to which each eigenvalue is required
        (only used when ``lapack_driver='stebz'``).
        An eigenvalue (or cluster) is considered to have converged if it
        lies in an interval of this width. If <= 0. (default),
        the value ``eps*|a|`` is used where eps is the machine precision,
        and ``|a|`` is the 1-norm of the matrix ``a``.
    lapack_driver : str
        LAPACK function to use, can be 'auto', 'stemr', 'stebz',  'sterf',
        or 'stev'. When 'auto' (default), it will use 'stemr' if ``select='a'``
        and 'stebz' otherwise. 'sterf' and 'stev' can only be used when
        ``select='a'``.
    
    Returns
    -------
    w : (M,) ndarray
        The eigenvalues, in ascending order, each repeated according to its
        multiplicity.
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge.
    
    See Also
    --------
    eigh_tridiagonal : eigenvalues and right eiegenvectors for
        symmetric/Hermitian tridiagonal matrices
    
    Examples
    --------
    >>> from scipy.linalg import eigvalsh_tridiagonal, eigvalsh
    >>> d = 3*np.ones(4)
    >>> e = -1*np.ones(3)
    >>> w = eigvalsh_tridiagonal(d, e)
    >>> A = np.diag(d) + np.diag(e, k=1) + np.diag(e, k=-1)
    >>> w2 = eigvalsh(A)  # Verify with other eigenvalue routines
    >>> np.allclose(w - w2, np.zeros(4))
    True
",function,"(""(d, e, select='a', select_range=None, check_finite=True, tol=0.0, lapack_driver='auto')"",)",scipy,1.1.0,scipy.linalg.eigvalsh_tridiagonal,linalg,eigvalsh_tridiagonal,"Python Library Documentation: function eigvalsh_tridiagonal in module scipy.linalg.decomp

eigvalsh_tridiagonal(d, e, select='a', select_range=None, check_finite=True, tol=0.0, lapack_driver='auto')
    Solve eigenvalue problem for a real symmetric tridiagonal matrix.
    
    Find eigenvalues `w` of ``a``::
    
        a v[:,i] = w[i] v[:,i]
        v.H v    = identity
    
    For a real symmetric matrix ``a`` with diagonal elements `d` and
    off-diagonal elements `e`.
    
    Parameters
    ----------
    d : ndarray, shape (ndim,)
        The diagonal elements of the array.
    e : ndarray, shape (ndim-1,)
        The off-diagonal elements of the array.
    select : {'a', 'v', 'i'}, optional
        Which eigenvalues to calculate
    
        ======  ========================================
        select  calculated
        ======  ========================================
        'a'     All eigenvalues
        'v'     Eigenvalues in the interval (min, max]
        'i'     Eigenvalues with indices min <= i <= max
        ======  ========================================
    select_range : (min, max), optional
        Range of selected eigenvalues
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    tol : float
        The absolute tolerance to which each eigenvalue is required
        (only used when ``lapack_driver='stebz'``).
        An eigenvalue (or cluster) is considered to have converged if it
        lies in an interval of this width. If <= 0. (default),
        the value ``eps*|a|`` is used where eps is the machine precision,
        and ``|a|`` is the 1-norm of the matrix ``a``.
    lapack_driver : str
        LAPACK function to use, can be 'auto', 'stemr', 'stebz',  'sterf',
        or 'stev'. When 'auto' (default), it will use 'stemr' if ``select='a'``
        and 'stebz' otherwise. 'sterf' and 'stev' can only be used when
        ``select='a'``.
    
    Returns
    -------
    w : (M,) ndarray
        The eigenvalues, in ascending order, each repeated according to its
        multiplicity.
    
    Raises
    ------
    LinAlgError
        If eigenvalue computation does not converge.
    
    See Also
    --------
    eigh_tridiagonal : eigenvalues and right eiegenvectors for
        symmetric/Hermitian tridiagonal matrices
    
    Examples
    --------
    >>> from scipy.linalg import eigvalsh_tridiagonal, eigvalsh
    >>> d = 3*np.ones(4)
    >>> e = -1*np.ones(3)
    >>> w = eigvalsh_tridiagonal(d, e)
    >>> A = np.diag(d) + np.diag(e, k=1) + np.diag(e, k=-1)
    >>> w2 = eigvalsh(A)  # Verify with other eigenvalue routines
    >>> np.allclose(w - w2, np.zeros(4))
    True
",function,"('d', 'e', 'select', 'select_range', 'check_finite', 'tol', 'lapack_driver')","(nan, nan, 'a', None, True, 0.0, 'auto')","(nan, nan, 'str', 'NoneType', 'bool', 'float', 'str')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(d, e, select='a', select_range=None, check_finite=True, tol=0.0, lapack_driver='auto')"",)"
scipy,1.1.0,scipy.linalg.expm,linalg,expm,"Python Library Documentation: function expm in module scipy.linalg.matfuncs

expm(A)
    Compute the matrix exponential using Pade approximation.
    
    Parameters
    ----------
    A : (N, N) array_like or sparse matrix
        Matrix to be exponentiated.
    
    Returns
    -------
    expm : (N, N) ndarray
        Matrix exponential of `A`.
    
    References
    ----------
    .. [1] Awad H. Al-Mohy and Nicholas J. Higham (2009)
           ""A New Scaling and Squaring Algorithm for the Matrix Exponential.""
           SIAM Journal on Matrix Analysis and Applications.
           31 (3). pp. 970-989. ISSN 1095-7162
    
    Examples
    --------
    >>> from scipy.linalg import expm, sinm, cosm
    
    Matrix version of the formula exp(0) = 1:
    
    >>> expm(np.zeros((2,2)))
    array([[ 1.,  0.],
           [ 0.,  1.]])
    
    Euler's identity (exp(i*theta) = cos(theta) + i*sin(theta))
    applied to a matrix:
    
    >>> a = np.array([[1.0, 2.0], [-1.0, 3.0]])
    >>> expm(1j*a)
    array([[ 0.42645930+1.89217551j, -2.13721484-0.97811252j],
           [ 1.06860742+0.48905626j, -1.71075555+0.91406299j]])
    >>> cosm(a) + 1j*sinm(a)
    array([[ 0.42645930+1.89217551j, -2.13721484-0.97811252j],
           [ 1.06860742+0.48905626j, -1.71075555+0.91406299j]])
",function,"('(A)',)",scipy,1.1.0,scipy.linalg.expm,linalg,expm,"Python Library Documentation: function expm in module scipy.linalg.matfuncs

expm(A)
    Compute the matrix exponential using Pade approximation.
    
    Parameters
    ----------
    A : (N, N) array_like or sparse matrix
        Matrix to be exponentiated.
    
    Returns
    -------
    expm : (N, N) ndarray
        Matrix exponential of `A`.
    
    References
    ----------
    .. [1] Awad H. Al-Mohy and Nicholas J. Higham (2009)
           ""A New Scaling and Squaring Algorithm for the Matrix Exponential.""
           SIAM Journal on Matrix Analysis and Applications.
           31 (3). pp. 970-989. ISSN 1095-7162
    
    Examples
    --------
    >>> from scipy.linalg import expm, sinm, cosm
    
    Matrix version of the formula exp(0) = 1:
    
    >>> expm(np.zeros((2,2)))
    array([[ 1.,  0.],
           [ 0.,  1.]])
    
    Euler's identity (exp(i*theta) = cos(theta) + i*sin(theta))
    applied to a matrix:
    
    >>> a = np.array([[1.0, 2.0], [-1.0, 3.0]])
    >>> expm(1j*a)
    array([[ 0.42645930+1.89217551j, -2.13721484-0.97811252j],
           [ 1.06860742+0.48905626j, -1.71075555+0.91406299j]])
    >>> cosm(a) + 1j*sinm(a)
    array([[ 0.42645930+1.89217551j, -2.13721484-0.97811252j],
           [ 1.06860742+0.48905626j, -1.71075555+0.91406299j]])
",function,"('A',)","(nan,)","(nan,)","('arg_info',)","('(A)',)"
scipy,1.1.0,scipy.linalg.expm_cond,linalg,expm_cond,"Python Library Documentation: function expm_cond in module scipy.linalg._expm_frechet

expm_cond(A, check_finite=True)
    Relative condition number of the matrix exponential in the Frobenius norm.
    
    Parameters
    ----------
    A : 2d array_like
        Square input matrix with shape (N, N).
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    kappa : float
        The relative condition number of the matrix exponential
        in the Frobenius norm
    
    Notes
    -----
    A faster estimate for the condition number in the 1-norm
    has been published but is not yet implemented in scipy.
    
    .. versionadded:: 0.14.0
    
    See also
    --------
    expm : Compute the exponential of a matrix.
    expm_frechet : Compute the Frechet derivative of the matrix exponential.
    
    Examples
    --------
    >>> from scipy.linalg import expm_cond
    >>> A = np.array([[-0.3, 0.2, 0.6], [0.6, 0.3, -0.1], [-0.7, 1.2, 0.9]])
    >>> k = expm_cond(A)
    >>> k
    1.7787805864469866
",function,"('(A, check_finite=True)',)",scipy,1.1.0,scipy.linalg.expm_cond,linalg,expm_cond,"Python Library Documentation: function expm_cond in module scipy.linalg._expm_frechet

expm_cond(A, check_finite=True)
    Relative condition number of the matrix exponential in the Frobenius norm.
    
    Parameters
    ----------
    A : 2d array_like
        Square input matrix with shape (N, N).
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    kappa : float
        The relative condition number of the matrix exponential
        in the Frobenius norm
    
    Notes
    -----
    A faster estimate for the condition number in the 1-norm
    has been published but is not yet implemented in scipy.
    
    .. versionadded:: 0.14.0
    
    See also
    --------
    expm : Compute the exponential of a matrix.
    expm_frechet : Compute the Frechet derivative of the matrix exponential.
    
    Examples
    --------
    >>> from scipy.linalg import expm_cond
    >>> A = np.array([[-0.3, 0.2, 0.6], [0.6, 0.3, -0.1], [-0.7, 1.2, 0.9]])
    >>> k = expm_cond(A)
    >>> k
    1.7787805864469866
",function,"('A', 'check_finite')","(nan, True)","(nan, 'bool')","('arg_info', 'arg_info')","('(A, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.expm_frechet,linalg,expm_frechet,"Python Library Documentation: function expm_frechet in module scipy.linalg._expm_frechet

expm_frechet(A, E, method=None, compute_expm=True, check_finite=True)
    Frechet derivative of the matrix exponential of A in the direction E.
    
    Parameters
    ----------
    A : (N, N) array_like
        Matrix of which to take the matrix exponential.
    E : (N, N) array_like
        Matrix direction in which to take the Frechet derivative.
    method : str, optional
        Choice of algorithm.  Should be one of
    
        - `SPS` (default)
        - `blockEnlarge`
    
    compute_expm : bool, optional
        Whether to compute also `expm_A` in addition to `expm_frechet_AE`.
        Default is True.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    expm_A : ndarray
        Matrix exponential of A.
    expm_frechet_AE : ndarray
        Frechet derivative of the matrix exponential of A in the direction E.
    
    For ``compute_expm = False``, only `expm_frechet_AE` is returned.
    
    See also
    --------
    expm : Compute the exponential of a matrix.
    
    Notes
    -----
    This section describes the available implementations that can be selected
    by the `method` parameter. The default method is *SPS*.
    
    Method *blockEnlarge* is a naive algorithm.
    
    Method *SPS* is Scaling-Pade-Squaring [1]_.
    It is a sophisticated implementation which should take
    only about 3/8 as much time as the naive implementation.
    The asymptotics are the same.
    
    .. versionadded:: 0.13.0
    
    References
    ----------
    .. [1] Awad H. Al-Mohy and Nicholas J. Higham (2009)
           Computing the Frechet Derivative of the Matrix Exponential,
           with an application to Condition Number Estimation.
           SIAM Journal On Matrix Analysis and Applications.,
           30 (4). pp. 1639-1657. ISSN 1095-7162
    
    Examples
    --------
    >>> import scipy.linalg
    >>> A = np.random.randn(3, 3)
    >>> E = np.random.randn(3, 3)
    >>> expm_A, expm_frechet_AE = scipy.linalg.expm_frechet(A, E)
    >>> expm_A.shape, expm_frechet_AE.shape
    ((3, 3), (3, 3))
    
    >>> import scipy.linalg
    >>> A = np.random.randn(3, 3)
    >>> E = np.random.randn(3, 3)
    >>> expm_A, expm_frechet_AE = scipy.linalg.expm_frechet(A, E)
    >>> M = np.zeros((6, 6))
    >>> M[:3, :3] = A; M[:3, 3:] = E; M[3:, 3:] = A
    >>> expm_M = scipy.linalg.expm(M)
    >>> np.allclose(expm_A, expm_M[:3, :3])
    True
    >>> np.allclose(expm_frechet_AE, expm_M[:3, 3:])
    True
",function,"('(A, E, method=None, compute_expm=True, check_finite=True)',)",scipy,1.1.0,scipy.linalg.expm_frechet,linalg,expm_frechet,"Python Library Documentation: function expm_frechet in module scipy.linalg._expm_frechet

expm_frechet(A, E, method=None, compute_expm=True, check_finite=True)
    Frechet derivative of the matrix exponential of A in the direction E.
    
    Parameters
    ----------
    A : (N, N) array_like
        Matrix of which to take the matrix exponential.
    E : (N, N) array_like
        Matrix direction in which to take the Frechet derivative.
    method : str, optional
        Choice of algorithm.  Should be one of
    
        - `SPS` (default)
        - `blockEnlarge`
    
    compute_expm : bool, optional
        Whether to compute also `expm_A` in addition to `expm_frechet_AE`.
        Default is True.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    expm_A : ndarray
        Matrix exponential of A.
    expm_frechet_AE : ndarray
        Frechet derivative of the matrix exponential of A in the direction E.
    
    For ``compute_expm = False``, only `expm_frechet_AE` is returned.
    
    See also
    --------
    expm : Compute the exponential of a matrix.
    
    Notes
    -----
    This section describes the available implementations that can be selected
    by the `method` parameter. The default method is *SPS*.
    
    Method *blockEnlarge* is a naive algorithm.
    
    Method *SPS* is Scaling-Pade-Squaring [1]_.
    It is a sophisticated implementation which should take
    only about 3/8 as much time as the naive implementation.
    The asymptotics are the same.
    
    .. versionadded:: 0.13.0
    
    References
    ----------
    .. [1] Awad H. Al-Mohy and Nicholas J. Higham (2009)
           Computing the Frechet Derivative of the Matrix Exponential,
           with an application to Condition Number Estimation.
           SIAM Journal On Matrix Analysis and Applications.,
           30 (4). pp. 1639-1657. ISSN 1095-7162
    
    Examples
    --------
    >>> import scipy.linalg
    >>> A = np.random.randn(3, 3)
    >>> E = np.random.randn(3, 3)
    >>> expm_A, expm_frechet_AE = scipy.linalg.expm_frechet(A, E)
    >>> expm_A.shape, expm_frechet_AE.shape
    ((3, 3), (3, 3))
    
    >>> import scipy.linalg
    >>> A = np.random.randn(3, 3)
    >>> E = np.random.randn(3, 3)
    >>> expm_A, expm_frechet_AE = scipy.linalg.expm_frechet(A, E)
    >>> M = np.zeros((6, 6))
    >>> M[:3, :3] = A; M[:3, 3:] = E; M[3:, 3:] = A
    >>> expm_M = scipy.linalg.expm(M)
    >>> np.allclose(expm_A, expm_M[:3, :3])
    True
    >>> np.allclose(expm_frechet_AE, expm_M[:3, 3:])
    True
",function,"('A', 'E', 'method', 'compute_expm', 'check_finite')","(nan, nan, None, True, True)","(nan, nan, 'NoneType', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(A, E, method=None, compute_expm=True, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.find_best_blas_type,linalg,find_best_blas_type,"Python Library Documentation: function find_best_blas_type in module scipy.linalg.blas

find_best_blas_type(arrays=(), dtype=None)
    Find best-matching BLAS/LAPACK type.
    
    Arrays are used to determine the optimal prefix of BLAS routines.
    
    Parameters
    ----------
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of BLAS
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    prefix : str
        BLAS/LAPACK prefix character.
    dtype : dtype
        Inferred Numpy data type.
    prefer_fortran : bool
        Whether to prefer Fortran order routines over C order.
    
    Examples
    --------
    >>> import scipy.linalg.blas as bla
    >>> a = np.random.rand(10,15)
    >>> b = np.asfortranarray(a)  # Change the memory layout order
    >>> bla.find_best_blas_type((a,))
    ('d', dtype('float64'), False)
    >>> bla.find_best_blas_type((a*1j,))
    ('z', dtype('complex128'), False)
    >>> bla.find_best_blas_type((b,))
    ('d', dtype('float64'), True)
",function,"('(arrays=(), dtype=None)',)",scipy,1.1.0,scipy.linalg.find_best_blas_type,linalg,find_best_blas_type,"Python Library Documentation: function find_best_blas_type in module scipy.linalg.blas

find_best_blas_type(arrays=(), dtype=None)
    Find best-matching BLAS/LAPACK type.
    
    Arrays are used to determine the optimal prefix of BLAS routines.
    
    Parameters
    ----------
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of BLAS
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    prefix : str
        BLAS/LAPACK prefix character.
    dtype : dtype
        Inferred Numpy data type.
    prefer_fortran : bool
        Whether to prefer Fortran order routines over C order.
    
    Examples
    --------
    >>> import scipy.linalg.blas as bla
    >>> a = np.random.rand(10,15)
    >>> b = np.asfortranarray(a)  # Change the memory layout order
    >>> bla.find_best_blas_type((a,))
    ('d', dtype('float64'), False)
    >>> bla.find_best_blas_type((a*1j,))
    ('z', dtype('complex128'), False)
    >>> bla.find_best_blas_type((b,))
    ('d', dtype('float64'), True)
",function,"('arrays', 'dtype')","((), None)","('tuple', 'NoneType')","('arg_info', 'arg_info')","('(arrays=(), dtype=None)',)"
scipy,1.1.0,scipy.linalg.flinalg.get_flinalg_funcs,linalg.flinalg,get_flinalg_funcs,"Python Library Documentation: function get_flinalg_funcs in module scipy.linalg.flinalg

get_flinalg_funcs(names, arrays=(), debug=0)
    Return optimal available _flinalg function objects with
    names. arrays are used to determine optimal prefix.
",function,"('(names, arrays=(), debug=0)',)",scipy,1.1.0,scipy.linalg.flinalg.get_flinalg_funcs,linalg.flinalg,get_flinalg_funcs,"Python Library Documentation: function get_flinalg_funcs in module scipy.linalg.flinalg

get_flinalg_funcs(names, arrays=(), debug=0)
    Return optimal available _flinalg function objects with
    names. arrays are used to determine optimal prefix.
",function,"('names', 'arrays', 'debug')","(nan, (), 0)","(nan, 'tuple', 'int')","('arg_info', 'arg_info', 'arg_info')","('(names, arrays=(), debug=0)',)"
scipy,1.1.0,scipy.linalg.flinalg.has_column_major_storage,linalg.flinalg,has_column_major_storage,"Python Library Documentation: function has_column_major_storage in module scipy.linalg.flinalg

has_column_major_storage(arr)
",function,"('(arr)',)",scipy,1.1.0,scipy.linalg.flinalg.has_column_major_storage,linalg.flinalg,has_column_major_storage,"Python Library Documentation: function has_column_major_storage in module scipy.linalg.flinalg

has_column_major_storage(arr)
",function,"('arr',)","(nan,)","(nan,)","('arg_info',)","('(arr)',)"
scipy,1.1.0,scipy.linalg.fractional_matrix_power,linalg,fractional_matrix_power,"Python Library Documentation: function fractional_matrix_power in module scipy.linalg.matfuncs

fractional_matrix_power(A, t)
    Compute the fractional power of a matrix.
    
    Proceeds according to the discussion in section (6) of [1]_.
    
    Parameters
    ----------
    A : (N, N) array_like
        Matrix whose fractional power to evaluate.
    t : float
        Fractional power.
    
    Returns
    -------
    X : (N, N) array_like
        The fractional power of the matrix.
    
    References
    ----------
    .. [1] Nicholas J. Higham and Lijing lin (2011)
           ""A Schur-Pade Algorithm for Fractional Powers of a Matrix.""
           SIAM Journal on Matrix Analysis and Applications,
           32 (3). pp. 1056-1078. ISSN 0895-4798
    
    Examples
    --------
    >>> from scipy.linalg import fractional_matrix_power
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> b = fractional_matrix_power(a, 0.5)
    >>> b
    array([[ 0.75592895,  1.13389342],
           [ 0.37796447,  1.88982237]])
    >>> np.dot(b, b)      # Verify square root
    array([[ 1.,  3.],
           [ 1.,  4.]])
",function,"('(A, t)',)",scipy,1.1.0,scipy.linalg.fractional_matrix_power,linalg,fractional_matrix_power,"Python Library Documentation: function fractional_matrix_power in module scipy.linalg.matfuncs

fractional_matrix_power(A, t)
    Compute the fractional power of a matrix.
    
    Proceeds according to the discussion in section (6) of [1]_.
    
    Parameters
    ----------
    A : (N, N) array_like
        Matrix whose fractional power to evaluate.
    t : float
        Fractional power.
    
    Returns
    -------
    X : (N, N) array_like
        The fractional power of the matrix.
    
    References
    ----------
    .. [1] Nicholas J. Higham and Lijing lin (2011)
           ""A Schur-Pade Algorithm for Fractional Powers of a Matrix.""
           SIAM Journal on Matrix Analysis and Applications,
           32 (3). pp. 1056-1078. ISSN 0895-4798
    
    Examples
    --------
    >>> from scipy.linalg import fractional_matrix_power
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> b = fractional_matrix_power(a, 0.5)
    >>> b
    array([[ 0.75592895,  1.13389342],
           [ 0.37796447,  1.88982237]])
    >>> np.dot(b, b)      # Verify square root
    array([[ 1.,  3.],
           [ 1.,  4.]])
",function,"('A', 't')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(A, t)',)"
scipy,1.1.0,scipy.linalg.funm,linalg,funm,"Python Library Documentation: function funm in module scipy.linalg.matfuncs

funm(A, func, disp=True)
    Evaluate a matrix function specified by a callable.
    
    Returns the value of matrix-valued function ``f`` at `A`. The
    function ``f`` is an extension of the scalar-valued function `func`
    to matrices.
    
    Parameters
    ----------
    A : (N, N) array_like
        Matrix at which to evaluate the function
    func : callable
        Callable object that evaluates a scalar function f.
        Must be vectorized (eg. using vectorize).
    disp : bool, optional
        Print warning if error in the result is estimated large
        instead of returning estimated error. (Default: True)
    
    Returns
    -------
    funm : (N, N) ndarray
        Value of the matrix function specified by func evaluated at `A`
    errest : float
        (if disp == False)
    
        1-norm of the estimated error, ||err||_1 / ||A||_1
    
    Examples
    --------
    >>> from scipy.linalg import funm
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> funm(a, lambda x: x*x)
    array([[  4.,  15.],
           [  5.,  19.]])
    >>> a.dot(a)
    array([[  4.,  15.],
           [  5.,  19.]])
    
    Notes
    -----
    This function implements the general algorithm based on Schur decomposition
    (Algorithm 9.1.1. in [1]_).
    
    If the input matrix is known to be diagonalizable, then relying on the
    eigendecomposition is likely to be faster. For example, if your matrix is
    Hermitian, you can do
    
    >>> from scipy.linalg import eigh
    >>> def funm_herm(a, func, check_finite=False):
    ...     w, v = eigh(a, check_finite=check_finite)
    ...     ## if you further know that your matrix is positive semidefinite,
    ...     ## you can optionally guard against precision errors by doing
    ...     # w = np.maximum(w, 0)
    ...     w = func(w)
    ...     return (v * w).dot(v.conj().T)
    
    References
    ----------
    .. [1] Gene H. Golub, Charles F. van Loan, Matrix Computations 4th ed.
",function,"('(A, func, disp=True)',)",scipy,1.1.0,scipy.linalg.funm,linalg,funm,"Python Library Documentation: function funm in module scipy.linalg.matfuncs

funm(A, func, disp=True)
    Evaluate a matrix function specified by a callable.
    
    Returns the value of matrix-valued function ``f`` at `A`. The
    function ``f`` is an extension of the scalar-valued function `func`
    to matrices.
    
    Parameters
    ----------
    A : (N, N) array_like
        Matrix at which to evaluate the function
    func : callable
        Callable object that evaluates a scalar function f.
        Must be vectorized (eg. using vectorize).
    disp : bool, optional
        Print warning if error in the result is estimated large
        instead of returning estimated error. (Default: True)
    
    Returns
    -------
    funm : (N, N) ndarray
        Value of the matrix function specified by func evaluated at `A`
    errest : float
        (if disp == False)
    
        1-norm of the estimated error, ||err||_1 / ||A||_1
    
    Examples
    --------
    >>> from scipy.linalg import funm
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> funm(a, lambda x: x*x)
    array([[  4.,  15.],
           [  5.,  19.]])
    >>> a.dot(a)
    array([[  4.,  15.],
           [  5.,  19.]])
    
    Notes
    -----
    This function implements the general algorithm based on Schur decomposition
    (Algorithm 9.1.1. in [1]_).
    
    If the input matrix is known to be diagonalizable, then relying on the
    eigendecomposition is likely to be faster. For example, if your matrix is
    Hermitian, you can do
    
    >>> from scipy.linalg import eigh
    >>> def funm_herm(a, func, check_finite=False):
    ...     w, v = eigh(a, check_finite=check_finite)
    ...     ## if you further know that your matrix is positive semidefinite,
    ...     ## you can optionally guard against precision errors by doing
    ...     # w = np.maximum(w, 0)
    ...     w = func(w)
    ...     return (v * w).dot(v.conj().T)
    
    References
    ----------
    .. [1] Gene H. Golub, Charles F. van Loan, Matrix Computations 4th ed.
",function,"('A', 'func', 'disp')","(nan, nan, True)","(nan, nan, 'bool')","('arg_info', 'arg_info', 'arg_info')","('(A, func, disp=True)',)"
scipy,1.1.0,scipy.linalg.get_blas_funcs,linalg,get_blas_funcs,"Python Library Documentation: function get_blas_funcs in module scipy.linalg.blas

get_blas_funcs(names, arrays=(), dtype=None)
    Return available BLAS function objects from names.
    
    Arrays are used to determine the optimal prefix of BLAS routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of BLAS functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of BLAS
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In BLAS, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively.
    The code and the dtype are stored in attributes `typecode` and `dtype`
    of the returned functions.
    
    Examples
    --------
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_gemv = LA.get_blas_funcs('gemv', (a,))
    >>> x_gemv.typecode
    'd'
    >>> x_gemv = LA.get_blas_funcs('gemv',(a*1j,))
    >>> x_gemv.typecode
    'z'
",function,"('(names, arrays=(), dtype=None)',)",scipy,1.1.0,scipy.linalg.get_blas_funcs,linalg,get_blas_funcs,"Python Library Documentation: function get_blas_funcs in module scipy.linalg.blas

get_blas_funcs(names, arrays=(), dtype=None)
    Return available BLAS function objects from names.
    
    Arrays are used to determine the optimal prefix of BLAS routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of BLAS functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of BLAS
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In BLAS, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively.
    The code and the dtype are stored in attributes `typecode` and `dtype`
    of the returned functions.
    
    Examples
    --------
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_gemv = LA.get_blas_funcs('gemv', (a,))
    >>> x_gemv.typecode
    'd'
    >>> x_gemv = LA.get_blas_funcs('gemv',(a*1j,))
    >>> x_gemv.typecode
    'z'
",function,"('names', 'arrays', 'dtype')","(nan, (), None)","(nan, 'tuple', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(names, arrays=(), dtype=None)',)"
scipy,1.1.0,scipy.linalg.get_lapack_funcs,linalg,get_lapack_funcs,"Python Library Documentation: function get_lapack_funcs in module scipy.linalg.lapack

get_lapack_funcs(names, arrays=(), dtype=None)
    Return available LAPACK function objects from names.
    
    Arrays are used to determine the optimal prefix of LAPACK routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of LAPACK functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of LAPACK
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In LAPACK, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively, and
    are stored in attribute ``typecode`` of the returned functions.
    
    Examples
    --------
    Suppose we would like to use '?lange' routine which computes the selected
    norm of an array. We pass our array in order to get the correct 'lange'
    flavor.
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_lange = LA.get_lapack_funcs('lange', (a,))
    >>> x_lange.typecode
    'd'
    >>> x_lange = LA.get_lapack_funcs('lange',(a*1j,))
    >>> x_lange.typecode
    'z'
    
    Several LAPACK routines work best when its internal WORK array has
    the optimal size (big enough for fast computation and small enough to
    avoid waste of memory). This size is determined also by a dedicated query
    to the function which is often wrapped as a standalone function and
    commonly denoted as ``###_lwork``. Below is an example for ``?sysv``
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(1000,1000)
    >>> b = np.random.rand(1000,1)*1j
    >>> # We pick up zsysv and zsysv_lwork due to b array
    ... xsysv, xlwork = LA.get_lapack_funcs(('sysv', 'sysv_lwork'), (a, b))
    >>> opt_lwork, _ = xlwork(a.shape[0])  # returns a complex for 'z' prefix
    >>> udut, ipiv, x, info = xsysv(a, b, lwork=int(opt_lwork.real))
",function,"('(names, arrays=(), dtype=None)',)",scipy,1.1.0,scipy.linalg.get_lapack_funcs,linalg,get_lapack_funcs,"Python Library Documentation: function get_lapack_funcs in module scipy.linalg.lapack

get_lapack_funcs(names, arrays=(), dtype=None)
    Return available LAPACK function objects from names.
    
    Arrays are used to determine the optimal prefix of LAPACK routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of LAPACK functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of LAPACK
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In LAPACK, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively, and
    are stored in attribute ``typecode`` of the returned functions.
    
    Examples
    --------
    Suppose we would like to use '?lange' routine which computes the selected
    norm of an array. We pass our array in order to get the correct 'lange'
    flavor.
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_lange = LA.get_lapack_funcs('lange', (a,))
    >>> x_lange.typecode
    'd'
    >>> x_lange = LA.get_lapack_funcs('lange',(a*1j,))
    >>> x_lange.typecode
    'z'
    
    Several LAPACK routines work best when its internal WORK array has
    the optimal size (big enough for fast computation and small enough to
    avoid waste of memory). This size is determined also by a dedicated query
    to the function which is often wrapped as a standalone function and
    commonly denoted as ``###_lwork``. Below is an example for ``?sysv``
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(1000,1000)
    >>> b = np.random.rand(1000,1)*1j
    >>> # We pick up zsysv and zsysv_lwork due to b array
    ... xsysv, xlwork = LA.get_lapack_funcs(('sysv', 'sysv_lwork'), (a, b))
    >>> opt_lwork, _ = xlwork(a.shape[0])  # returns a complex for 'z' prefix
    >>> udut, ipiv, x, info = xsysv(a, b, lwork=int(opt_lwork.real))
",function,"('names', 'arrays', 'dtype')","(nan, (), None)","(nan, 'tuple', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(names, arrays=(), dtype=None)',)"
scipy,1.1.0,scipy.linalg.hadamard,linalg,hadamard,"Python Library Documentation: function hadamard in module scipy.linalg.special_matrices

hadamard(n, dtype=<class 'int'>)
    Construct a Hadamard matrix.
    
    Constructs an n-by-n Hadamard matrix, using Sylvester's
    construction.  `n` must be a power of 2.
    
    Parameters
    ----------
    n : int
        The order of the matrix.  `n` must be a power of 2.
    dtype : dtype, optional
        The data type of the array to be constructed.
    
    Returns
    -------
    H : (n, n) ndarray
        The Hadamard matrix.
    
    Notes
    -----
    .. versionadded:: 0.8.0
    
    Examples
    --------
    >>> from scipy.linalg import hadamard
    >>> hadamard(2, dtype=complex)
    array([[ 1.+0.j,  1.+0.j],
           [ 1.+0.j, -1.-0.j]])
    >>> hadamard(4)
    array([[ 1,  1,  1,  1],
           [ 1, -1,  1, -1],
           [ 1,  1, -1, -1],
           [ 1, -1, -1,  1]])
",function,"(""(n, dtype=<class 'int'>)"",)",scipy,1.1.0,scipy.linalg.hadamard,linalg,hadamard,"Python Library Documentation: function hadamard in module scipy.linalg.special_matrices

hadamard(n, dtype=<class 'int'>)
    Construct a Hadamard matrix.
    
    Constructs an n-by-n Hadamard matrix, using Sylvester's
    construction.  `n` must be a power of 2.
    
    Parameters
    ----------
    n : int
        The order of the matrix.  `n` must be a power of 2.
    dtype : dtype, optional
        The data type of the array to be constructed.
    
    Returns
    -------
    H : (n, n) ndarray
        The Hadamard matrix.
    
    Notes
    -----
    .. versionadded:: 0.8.0
    
    Examples
    --------
    >>> from scipy.linalg import hadamard
    >>> hadamard(2, dtype=complex)
    array([[ 1.+0.j,  1.+0.j],
           [ 1.+0.j, -1.-0.j]])
    >>> hadamard(4)
    array([[ 1,  1,  1,  1],
           [ 1, -1,  1, -1],
           [ 1,  1, -1, -1],
           [ 1, -1, -1,  1]])
",function,"('n', 'dtype')","(nan, <class 'int'>)","(nan, 'type')","('arg_info', 'arg_info')","(""(n, dtype=<class 'int'>)"",)"
scipy,1.1.0,scipy.linalg.hankel,linalg,hankel,"Python Library Documentation: function hankel in module scipy.linalg.special_matrices

hankel(c, r=None)
    Construct a Hankel matrix.
    
    The Hankel matrix has constant anti-diagonals, with `c` as its
    first column and `r` as its last row.  If `r` is not given, then
    `r = zeros_like(c)` is assumed.
    
    Parameters
    ----------
    c : array_like
        First column of the matrix.  Whatever the actual shape of `c`, it
        will be converted to a 1-D array.
    r : array_like, optional
        Last row of the matrix. If None, ``r = zeros_like(c)`` is assumed.
        r[0] is ignored; the last row of the returned matrix is
        ``[c[-1], r[1:]]``.  Whatever the actual shape of `r`, it will be
        converted to a 1-D array.
    
    Returns
    -------
    A : (len(c), len(r)) ndarray
        The Hankel matrix. Dtype is the same as ``(c[0] + r[0]).dtype``.
    
    See Also
    --------
    toeplitz : Toeplitz matrix
    circulant : circulant matrix
    
    Examples
    --------
    >>> from scipy.linalg import hankel
    >>> hankel([1, 17, 99])
    array([[ 1, 17, 99],
           [17, 99,  0],
           [99,  0,  0]])
    >>> hankel([1,2,3,4], [4,7,7,8,9])
    array([[1, 2, 3, 4, 7],
           [2, 3, 4, 7, 7],
           [3, 4, 7, 7, 8],
           [4, 7, 7, 8, 9]])
",function,"('(c, r=None)',)",scipy,1.1.0,scipy.linalg.hankel,linalg,hankel,"Python Library Documentation: function hankel in module scipy.linalg.special_matrices

hankel(c, r=None)
    Construct a Hankel matrix.
    
    The Hankel matrix has constant anti-diagonals, with `c` as its
    first column and `r` as its last row.  If `r` is not given, then
    `r = zeros_like(c)` is assumed.
    
    Parameters
    ----------
    c : array_like
        First column of the matrix.  Whatever the actual shape of `c`, it
        will be converted to a 1-D array.
    r : array_like, optional
        Last row of the matrix. If None, ``r = zeros_like(c)`` is assumed.
        r[0] is ignored; the last row of the returned matrix is
        ``[c[-1], r[1:]]``.  Whatever the actual shape of `r`, it will be
        converted to a 1-D array.
    
    Returns
    -------
    A : (len(c), len(r)) ndarray
        The Hankel matrix. Dtype is the same as ``(c[0] + r[0]).dtype``.
    
    See Also
    --------
    toeplitz : Toeplitz matrix
    circulant : circulant matrix
    
    Examples
    --------
    >>> from scipy.linalg import hankel
    >>> hankel([1, 17, 99])
    array([[ 1, 17, 99],
           [17, 99,  0],
           [99,  0,  0]])
    >>> hankel([1,2,3,4], [4,7,7,8,9])
    array([[1, 2, 3, 4, 7],
           [2, 3, 4, 7, 7],
           [3, 4, 7, 7, 8],
           [4, 7, 7, 8, 9]])
",function,"('c', 'r')","(nan, None)","(nan, 'NoneType')","('arg_info', 'arg_info')","('(c, r=None)',)"
scipy,1.1.0,scipy.linalg.helmert,linalg,helmert,"Python Library Documentation: function helmert in module scipy.linalg.special_matrices

helmert(n, full=False)
    Create a Helmert matrix of order `n`.
    
    This has applications in statistics, compositional or simplicial analysis,
    and in Aitchison geometry.
    
    Parameters
    ----------
    n : int
        The size of the array to create.
    full : bool, optional
        If True the (n, n) ndarray will be returned.
        Otherwise the submatrix that does not include the first
        row will be returned.
        Default: False.
    
    Returns
    -------
    M : ndarray
        The Helmert matrix.
        The shape is (n, n) or (n-1, n) depending on the `full` argument.
    
    Examples
    --------
    >>> from scipy.linalg import helmert
    >>> helmert(5, full=True)
    array([[ 0.4472136 ,  0.4472136 ,  0.4472136 ,  0.4472136 ,  0.4472136 ],
           [ 0.70710678, -0.70710678,  0.        ,  0.        ,  0.        ],
           [ 0.40824829,  0.40824829, -0.81649658,  0.        ,  0.        ],
           [ 0.28867513,  0.28867513,  0.28867513, -0.8660254 ,  0.        ],
           [ 0.2236068 ,  0.2236068 ,  0.2236068 ,  0.2236068 , -0.89442719]])
",function,"('(n, full=False)',)",scipy,1.1.0,scipy.linalg.helmert,linalg,helmert,"Python Library Documentation: function helmert in module scipy.linalg.special_matrices

helmert(n, full=False)
    Create a Helmert matrix of order `n`.
    
    This has applications in statistics, compositional or simplicial analysis,
    and in Aitchison geometry.
    
    Parameters
    ----------
    n : int
        The size of the array to create.
    full : bool, optional
        If True the (n, n) ndarray will be returned.
        Otherwise the submatrix that does not include the first
        row will be returned.
        Default: False.
    
    Returns
    -------
    M : ndarray
        The Helmert matrix.
        The shape is (n, n) or (n-1, n) depending on the `full` argument.
    
    Examples
    --------
    >>> from scipy.linalg import helmert
    >>> helmert(5, full=True)
    array([[ 0.4472136 ,  0.4472136 ,  0.4472136 ,  0.4472136 ,  0.4472136 ],
           [ 0.70710678, -0.70710678,  0.        ,  0.        ,  0.        ],
           [ 0.40824829,  0.40824829, -0.81649658,  0.        ,  0.        ],
           [ 0.28867513,  0.28867513,  0.28867513, -0.8660254 ,  0.        ],
           [ 0.2236068 ,  0.2236068 ,  0.2236068 ,  0.2236068 , -0.89442719]])
",function,"('n', 'full')","(nan, False)","(nan, 'bool')","('arg_info', 'arg_info')","('(n, full=False)',)"
scipy,1.1.0,scipy.linalg.hessenberg,linalg,hessenberg,"Python Library Documentation: function hessenberg in module scipy.linalg.decomp

hessenberg(a, calc_q=False, overwrite_a=False, check_finite=True)
    Compute Hessenberg form of a matrix.
    
    The Hessenberg decomposition is::
    
        A = Q H Q^H
    
    where `Q` is unitary/orthogonal and `H` has only zero elements below
    the first sub-diagonal.
    
    Parameters
    ----------
    a : (M, M) array_like
        Matrix to bring into Hessenberg form.
    calc_q : bool, optional
        Whether to compute the transformation matrix.  Default is False.
    overwrite_a : bool, optional
        Whether to overwrite `a`; may improve performance.
        Default is False.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    H : (M, M) ndarray
        Hessenberg form of `a`.
    Q : (M, M) ndarray
        Unitary/orthogonal similarity transformation matrix ``A = Q H Q^H``.
        Only returned if ``calc_q=True``.
    
    Examples
    --------
    >>> from scipy.linalg import hessenberg
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> H, Q = hessenberg(A, calc_q=True)
    >>> H
    array([[  2.        , -11.65843866,   1.42005301,   0.25349066],
           [ -9.94987437,  14.53535354,  -5.31022304,   2.43081618],
           [  0.        ,  -1.83299243,   0.38969961,  -0.51527034],
           [  0.        ,   0.        ,  -3.83189513,   1.07494686]])
    >>> np.allclose(Q @ H @ Q.conj().T - A, np.zeros((4, 4)))
    True
",function,"('(a, calc_q=False, overwrite_a=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.hessenberg,linalg,hessenberg,"Python Library Documentation: function hessenberg in module scipy.linalg.decomp

hessenberg(a, calc_q=False, overwrite_a=False, check_finite=True)
    Compute Hessenberg form of a matrix.
    
    The Hessenberg decomposition is::
    
        A = Q H Q^H
    
    where `Q` is unitary/orthogonal and `H` has only zero elements below
    the first sub-diagonal.
    
    Parameters
    ----------
    a : (M, M) array_like
        Matrix to bring into Hessenberg form.
    calc_q : bool, optional
        Whether to compute the transformation matrix.  Default is False.
    overwrite_a : bool, optional
        Whether to overwrite `a`; may improve performance.
        Default is False.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    H : (M, M) ndarray
        Hessenberg form of `a`.
    Q : (M, M) ndarray
        Unitary/orthogonal similarity transformation matrix ``A = Q H Q^H``.
        Only returned if ``calc_q=True``.
    
    Examples
    --------
    >>> from scipy.linalg import hessenberg
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> H, Q = hessenberg(A, calc_q=True)
    >>> H
    array([[  2.        , -11.65843866,   1.42005301,   0.25349066],
           [ -9.94987437,  14.53535354,  -5.31022304,   2.43081618],
           [  0.        ,  -1.83299243,   0.38969961,  -0.51527034],
           [  0.        ,   0.        ,  -3.83189513,   1.07494686]])
    >>> np.allclose(Q @ H @ Q.conj().T - A, np.zeros((4, 4)))
    True
",function,"('a', 'calc_q', 'overwrite_a', 'check_finite')","(nan, False, False, True)","(nan, 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, calc_q=False, overwrite_a=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.hilbert,linalg,hilbert,"Python Library Documentation: function hilbert in module scipy.linalg.special_matrices

hilbert(n)
    Create a Hilbert matrix of order `n`.
    
    Returns the `n` by `n` array with entries `h[i,j] = 1 / (i + j + 1)`.
    
    Parameters
    ----------
    n : int
        The size of the array to create.
    
    Returns
    -------
    h : (n, n) ndarray
        The Hilbert matrix.
    
    See Also
    --------
    invhilbert : Compute the inverse of a Hilbert matrix.
    
    Notes
    -----
    .. versionadded:: 0.10.0
    
    Examples
    --------
    >>> from scipy.linalg import hilbert
    >>> hilbert(3)
    array([[ 1.        ,  0.5       ,  0.33333333],
           [ 0.5       ,  0.33333333,  0.25      ],
           [ 0.33333333,  0.25      ,  0.2       ]])
",function,"('(n)',)",scipy,1.1.0,scipy.linalg.hilbert,linalg,hilbert,"Python Library Documentation: function hilbert in module scipy.linalg.special_matrices

hilbert(n)
    Create a Hilbert matrix of order `n`.
    
    Returns the `n` by `n` array with entries `h[i,j] = 1 / (i + j + 1)`.
    
    Parameters
    ----------
    n : int
        The size of the array to create.
    
    Returns
    -------
    h : (n, n) ndarray
        The Hilbert matrix.
    
    See Also
    --------
    invhilbert : Compute the inverse of a Hilbert matrix.
    
    Notes
    -----
    .. versionadded:: 0.10.0
    
    Examples
    --------
    >>> from scipy.linalg import hilbert
    >>> hilbert(3)
    array([[ 1.        ,  0.5       ,  0.33333333],
           [ 0.5       ,  0.33333333,  0.25      ],
           [ 0.33333333,  0.25      ,  0.2       ]])
",function,"('n',)","(nan,)","(nan,)","('arg_info',)","('(n)',)"
scipy,1.1.0,scipy.linalg.inv,linalg,inv,"Python Library Documentation: function inv in module scipy.linalg.basic

inv(a, overwrite_a=False, check_finite=True)
    Compute the inverse of a matrix.
    
    Parameters
    ----------
    a : array_like
        Square matrix to be inverted.
    overwrite_a : bool, optional
        Discard data in `a` (may improve performance). Default is False.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    ainv : ndarray
        Inverse of the matrix `a`.
    
    Raises
    ------
    LinAlgError
        If `a` is singular.
    ValueError
        If `a` is not square, or not 2-dimensional.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.array([[1., 2.], [3., 4.]])
    >>> linalg.inv(a)
    array([[-2. ,  1. ],
           [ 1.5, -0.5]])
    >>> np.dot(a, linalg.inv(a))
    array([[ 1.,  0.],
           [ 0.,  1.]])
",function,"('(a, overwrite_a=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.inv,linalg,inv,"Python Library Documentation: function inv in module scipy.linalg.basic

inv(a, overwrite_a=False, check_finite=True)
    Compute the inverse of a matrix.
    
    Parameters
    ----------
    a : array_like
        Square matrix to be inverted.
    overwrite_a : bool, optional
        Discard data in `a` (may improve performance). Default is False.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    ainv : ndarray
        Inverse of the matrix `a`.
    
    Raises
    ------
    LinAlgError
        If `a` is singular.
    ValueError
        If `a` is not square, or not 2-dimensional.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.array([[1., 2.], [3., 4.]])
    >>> linalg.inv(a)
    array([[-2. ,  1. ],
           [ 1.5, -0.5]])
    >>> np.dot(a, linalg.inv(a))
    array([[ 1.,  0.],
           [ 0.,  1.]])
",function,"('a', 'overwrite_a', 'check_finite')","(nan, False, True)","(nan, 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info')","('(a, overwrite_a=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.invhilbert,linalg,invhilbert,"Python Library Documentation: function invhilbert in module scipy.linalg.special_matrices

invhilbert(n, exact=False)
    Compute the inverse of the Hilbert matrix of order `n`.
    
    The entries in the inverse of a Hilbert matrix are integers.  When `n`
    is greater than 14, some entries in the inverse exceed the upper limit
    of 64 bit integers.  The `exact` argument provides two options for
    dealing with these large integers.
    
    Parameters
    ----------
    n : int
        The order of the Hilbert matrix.
    exact : bool, optional
        If False, the data type of the array that is returned is np.float64,
        and the array is an approximation of the inverse.
        If True, the array is the exact integer inverse array.  To represent
        the exact inverse when n > 14, the returned array is an object array
        of long integers.  For n <= 14, the exact inverse is returned as an
        array with data type np.int64.
    
    Returns
    -------
    invh : (n, n) ndarray
        The data type of the array is np.float64 if `exact` is False.
        If `exact` is True, the data type is either np.int64 (for n <= 14)
        or object (for n > 14).  In the latter case, the objects in the
        array will be long integers.
    
    See Also
    --------
    hilbert : Create a Hilbert matrix.
    
    Notes
    -----
    .. versionadded:: 0.10.0
    
    Examples
    --------
    >>> from scipy.linalg import invhilbert
    >>> invhilbert(4)
    array([[   16.,  -120.,   240.,  -140.],
           [ -120.,  1200., -2700.,  1680.],
           [  240., -2700.,  6480., -4200.],
           [ -140.,  1680., -4200.,  2800.]])
    >>> invhilbert(4, exact=True)
    array([[   16,  -120,   240,  -140],
           [ -120,  1200, -2700,  1680],
           [  240, -2700,  6480, -4200],
           [ -140,  1680, -4200,  2800]], dtype=int64)
    >>> invhilbert(16)[7,7]
    4.2475099528537506e+19
    >>> invhilbert(16, exact=True)[7,7]
    42475099528537378560L
",function,"('(n, exact=False)',)",scipy,1.1.0,scipy.linalg.invhilbert,linalg,invhilbert,"Python Library Documentation: function invhilbert in module scipy.linalg.special_matrices

invhilbert(n, exact=False)
    Compute the inverse of the Hilbert matrix of order `n`.
    
    The entries in the inverse of a Hilbert matrix are integers.  When `n`
    is greater than 14, some entries in the inverse exceed the upper limit
    of 64 bit integers.  The `exact` argument provides two options for
    dealing with these large integers.
    
    Parameters
    ----------
    n : int
        The order of the Hilbert matrix.
    exact : bool, optional
        If False, the data type of the array that is returned is np.float64,
        and the array is an approximation of the inverse.
        If True, the array is the exact integer inverse array.  To represent
        the exact inverse when n > 14, the returned array is an object array
        of long integers.  For n <= 14, the exact inverse is returned as an
        array with data type np.int64.
    
    Returns
    -------
    invh : (n, n) ndarray
        The data type of the array is np.float64 if `exact` is False.
        If `exact` is True, the data type is either np.int64 (for n <= 14)
        or object (for n > 14).  In the latter case, the objects in the
        array will be long integers.
    
    See Also
    --------
    hilbert : Create a Hilbert matrix.
    
    Notes
    -----
    .. versionadded:: 0.10.0
    
    Examples
    --------
    >>> from scipy.linalg import invhilbert
    >>> invhilbert(4)
    array([[   16.,  -120.,   240.,  -140.],
           [ -120.,  1200., -2700.,  1680.],
           [  240., -2700.,  6480., -4200.],
           [ -140.,  1680., -4200.,  2800.]])
    >>> invhilbert(4, exact=True)
    array([[   16,  -120,   240,  -140],
           [ -120,  1200, -2700,  1680],
           [  240, -2700,  6480, -4200],
           [ -140,  1680, -4200,  2800]], dtype=int64)
    >>> invhilbert(16)[7,7]
    4.2475099528537506e+19
    >>> invhilbert(16, exact=True)[7,7]
    42475099528537378560L
",function,"('n', 'exact')","(nan, False)","(nan, 'bool')","('arg_info', 'arg_info')","('(n, exact=False)',)"
scipy,1.1.0,scipy.linalg.invpascal,linalg,invpascal,"Python Library Documentation: function invpascal in module scipy.linalg.special_matrices

invpascal(n, kind='symmetric', exact=True)
    Returns the inverse of the n x n Pascal matrix.
    
    The Pascal matrix is a matrix containing the binomial coefficients as
    its elements.
    
    Parameters
    ----------
    n : int
        The size of the matrix to create; that is, the result is an n x n
        matrix.
    kind : str, optional
        Must be one of 'symmetric', 'lower', or 'upper'.
        Default is 'symmetric'.
    exact : bool, optional
        If `exact` is True, the result is either an array of type
        `numpy.int64` (if `n` <= 35) or an object array of Python integers.
        If `exact` is False, the coefficients in the matrix are computed using
        `scipy.special.comb` with `exact=False`.  The result will be a floating
        point array, and for large `n`, the values in the array will not be the
        exact coefficients.
    
    Returns
    -------
    invp : (n, n) ndarray
        The inverse of the Pascal matrix.
    
    See Also
    --------
    pascal
    
    Notes
    -----
    
    .. versionadded:: 0.16.0
    
    References
    ----------
    .. [1] ""Pascal matrix"",  http://en.wikipedia.org/wiki/Pascal_matrix
    .. [2] Cohen, A. M., ""The inverse of a Pascal matrix"", Mathematical
           Gazette, 59(408), pp. 111-112, 1975.
    
    Examples
    --------
    >>> from scipy.linalg import invpascal, pascal
    >>> invp = invpascal(5)
    >>> invp
    array([[  5, -10,  10,  -5,   1],
           [-10,  30, -35,  19,  -4],
           [ 10, -35,  46, -27,   6],
           [ -5,  19, -27,  17,  -4],
           [  1,  -4,   6,  -4,   1]])
    
    >>> p = pascal(5)
    >>> p.dot(invp)
    array([[ 1.,  0.,  0.,  0.,  0.],
           [ 0.,  1.,  0.,  0.,  0.],
           [ 0.,  0.,  1.,  0.,  0.],
           [ 0.,  0.,  0.,  1.,  0.],
           [ 0.,  0.,  0.,  0.,  1.]])
    
    An example of the use of `kind` and `exact`:
    
    >>> invpascal(5, kind='lower', exact=False)
    array([[ 1., -0.,  0., -0.,  0.],
           [-1.,  1., -0.,  0., -0.],
           [ 1., -2.,  1., -0.,  0.],
           [-1.,  3., -3.,  1., -0.],
           [ 1., -4.,  6., -4.,  1.]])
",function,"(""(n, kind='symmetric', exact=True)"",)",scipy,1.1.0,scipy.linalg.invpascal,linalg,invpascal,"Python Library Documentation: function invpascal in module scipy.linalg.special_matrices

invpascal(n, kind='symmetric', exact=True)
    Returns the inverse of the n x n Pascal matrix.
    
    The Pascal matrix is a matrix containing the binomial coefficients as
    its elements.
    
    Parameters
    ----------
    n : int
        The size of the matrix to create; that is, the result is an n x n
        matrix.
    kind : str, optional
        Must be one of 'symmetric', 'lower', or 'upper'.
        Default is 'symmetric'.
    exact : bool, optional
        If `exact` is True, the result is either an array of type
        `numpy.int64` (if `n` <= 35) or an object array of Python integers.
        If `exact` is False, the coefficients in the matrix are computed using
        `scipy.special.comb` with `exact=False`.  The result will be a floating
        point array, and for large `n`, the values in the array will not be the
        exact coefficients.
    
    Returns
    -------
    invp : (n, n) ndarray
        The inverse of the Pascal matrix.
    
    See Also
    --------
    pascal
    
    Notes
    -----
    
    .. versionadded:: 0.16.0
    
    References
    ----------
    .. [1] ""Pascal matrix"",  http://en.wikipedia.org/wiki/Pascal_matrix
    .. [2] Cohen, A. M., ""The inverse of a Pascal matrix"", Mathematical
           Gazette, 59(408), pp. 111-112, 1975.
    
    Examples
    --------
    >>> from scipy.linalg import invpascal, pascal
    >>> invp = invpascal(5)
    >>> invp
    array([[  5, -10,  10,  -5,   1],
           [-10,  30, -35,  19,  -4],
           [ 10, -35,  46, -27,   6],
           [ -5,  19, -27,  17,  -4],
           [  1,  -4,   6,  -4,   1]])
    
    >>> p = pascal(5)
    >>> p.dot(invp)
    array([[ 1.,  0.,  0.,  0.,  0.],
           [ 0.,  1.,  0.,  0.,  0.],
           [ 0.,  0.,  1.,  0.,  0.],
           [ 0.,  0.,  0.,  1.,  0.],
           [ 0.,  0.,  0.,  0.,  1.]])
    
    An example of the use of `kind` and `exact`:
    
    >>> invpascal(5, kind='lower', exact=False)
    array([[ 1., -0.,  0., -0.,  0.],
           [-1.,  1., -0.,  0., -0.],
           [ 1., -2.,  1., -0.,  0.],
           [-1.,  3., -3.,  1., -0.],
           [ 1., -4.,  6., -4.,  1.]])
",function,"('n', 'kind', 'exact')","(nan, 'symmetric', True)","(nan, 'str', 'bool')","('arg_info', 'arg_info', 'arg_info')","(""(n, kind='symmetric', exact=True)"",)"
scipy,1.1.0,scipy.linalg.kron,linalg,kron,"Python Library Documentation: function kron in module scipy.linalg.special_matrices

kron(a, b)
    Kronecker product.
    
    The result is the block matrix::
    
        a[0,0]*b    a[0,1]*b  ... a[0,-1]*b
        a[1,0]*b    a[1,1]*b  ... a[1,-1]*b
        ...
        a[-1,0]*b   a[-1,1]*b ... a[-1,-1]*b
    
    Parameters
    ----------
    a : (M, N) ndarray
        Input array
    b : (P, Q) ndarray
        Input array
    
    Returns
    -------
    A : (M*P, N*Q) ndarray
        Kronecker product of `a` and `b`.
    
    Examples
    --------
    >>> from numpy import array
    >>> from scipy.linalg import kron
    >>> kron(array([[1,2],[3,4]]), array([[1,1,1]]))
    array([[1, 1, 1, 2, 2, 2],
           [3, 3, 3, 4, 4, 4]])
",function,"('(a, b)',)",scipy,1.1.0,scipy.linalg.kron,linalg,kron,"Python Library Documentation: function kron in module scipy.linalg.special_matrices

kron(a, b)
    Kronecker product.
    
    The result is the block matrix::
    
        a[0,0]*b    a[0,1]*b  ... a[0,-1]*b
        a[1,0]*b    a[1,1]*b  ... a[1,-1]*b
        ...
        a[-1,0]*b   a[-1,1]*b ... a[-1,-1]*b
    
    Parameters
    ----------
    a : (M, N) ndarray
        Input array
    b : (P, Q) ndarray
        Input array
    
    Returns
    -------
    A : (M*P, N*Q) ndarray
        Kronecker product of `a` and `b`.
    
    Examples
    --------
    >>> from numpy import array
    >>> from scipy.linalg import kron
    >>> kron(array([[1,2],[3,4]]), array([[1,1,1]]))
    array([[1, 1, 1, 2, 2, 2],
           [3, 3, 3, 4, 4, 4]])
",function,"('a', 'b')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(a, b)',)"
scipy,1.1.0,scipy.linalg.lapack._DeprecatedImport,linalg.lapack,DeprecatedImport,"Python Library Documentation: class DeprecatedImport in module scipy._lib._util

class DeprecatedImport(builtins.object)
 |  Deprecated import, with redirection + warning.
 |  
 |  Examples
 |  --------
 |  Suppose you previously had in some module::
 |  
 |      from foo import spam
 |  
 |  If this has to be deprecated, do::
 |  
 |      spam = DeprecatedImport(""foo.spam"", ""baz"")
 |  
 |  to redirect users to use ""baz"" module instead.
 |  
 |  Methods defined here:
 |  
 |  __dir__(self)
 |      __dir__() -> list
 |      default dir() implementation
 |  
 |  __getattr__(self, name)
 |  
 |  __init__(self, old_module_name, new_module_name)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('(self, old_module_name, new_module_name)',)",scipy,1.1.0,scipy.linalg.lapack._DeprecatedImport,linalg.lapack,DeprecatedImport,"Python Library Documentation: class DeprecatedImport in module scipy._lib._util

class DeprecatedImport(builtins.object)
 |  Deprecated import, with redirection + warning.
 |  
 |  Examples
 |  --------
 |  Suppose you previously had in some module::
 |  
 |      from foo import spam
 |  
 |  If this has to be deprecated, do::
 |  
 |      spam = DeprecatedImport(""foo.spam"", ""baz"")
 |  
 |  to redirect users to use ""baz"" module instead.
 |  
 |  Methods defined here:
 |  
 |  __dir__(self)
 |      __dir__() -> list
 |      default dir() implementation
 |  
 |  __getattr__(self, name)
 |  
 |  __init__(self, old_module_name, new_module_name)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
",class,"('self', 'old_module_name', 'new_module_name')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(self, old_module_name, new_module_name)',)"
scipy,1.1.0,scipy.linalg.lapack._compute_lwork,linalg.lapack,_compute_lwork,"Python Library Documentation: function _compute_lwork in module scipy.linalg.lapack

_compute_lwork(routine, *args, **kwargs)
    Round floating-point lwork returned by lapack to integer.
    
    Several LAPACK routines compute optimal values for LWORK, which
    they return in a floating-point variable. However, for large
    values of LWORK, single-precision floating point is not sufficient
    to hold the exact value --- some LAPACK versions (<= 3.5.0 at
    least) truncate the returned integer to single precision and in
    some cases this can be smaller than the required value.
    
    Examples
    --------
    >>> from scipy.linalg import lapack
    >>> n = 5000
    >>> s_r, s_lw = lapack.get_lapack_funcs(('sysvx', 'sysvx_lwork'))
    >>> lwork = lapack._compute_lwork(s_lw, n)
    >>> lwork
    32000
",function,"('(routine, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg.lapack._compute_lwork,linalg.lapack,_compute_lwork,"Python Library Documentation: function _compute_lwork in module scipy.linalg.lapack

_compute_lwork(routine, *args, **kwargs)
    Round floating-point lwork returned by lapack to integer.
    
    Several LAPACK routines compute optimal values for LWORK, which
    they return in a floating-point variable. However, for large
    values of LWORK, single-precision floating point is not sufficient
    to hold the exact value --- some LAPACK versions (<= 3.5.0 at
    least) truncate the returned integer to single precision and in
    some cases this can be smaller than the required value.
    
    Examples
    --------
    >>> from scipy.linalg import lapack
    >>> n = 5000
    >>> s_r, s_lw = lapack.get_lapack_funcs(('sysvx', 'sysvx_lwork'))
    >>> lwork = lapack._compute_lwork(s_lw, n)
    >>> lwork
    32000
",function,"('routine',)","(nan,)","(nan,)","('arg_info',)","('(routine, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg.lapack._get_funcs,linalg.lapack,_get_funcs,"Python Library Documentation: function _get_funcs in module scipy.linalg.blas

_get_funcs(names, arrays, dtype, lib_name, fmodule, cmodule, fmodule_name, cmodule_name, alias)
    Return available BLAS/LAPACK functions.
    
    Used also in lapack.py. See get_blas_funcs for docstring.
",function,"('(names, arrays, dtype, lib_name, fmodule, cmodule, fmodule_name, cmodule_name, alias)',)",scipy,1.1.0,scipy.linalg.lapack._get_funcs,linalg.lapack,_get_funcs,"Python Library Documentation: function _get_funcs in module scipy.linalg.blas

_get_funcs(names, arrays, dtype, lib_name, fmodule, cmodule, fmodule_name, cmodule_name, alias)
    Return available BLAS/LAPACK functions.
    
    Used also in lapack.py. See get_blas_funcs for docstring.
",function,"('names', 'arrays', 'dtype', 'lib_name', 'fmodule', 'cmodule', 'fmodule_name', 'cmodule_name', 'alias')","(nan, nan, nan, nan, nan, nan, nan, nan, nan)","(nan, nan, nan, nan, nan, nan, nan, nan, nan)","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(names, arrays, dtype, lib_name, fmodule, cmodule, fmodule_name, cmodule_name, alias)',)"
scipy,1.1.0,scipy.linalg.lapack.cgegv,linalg.lapack,cgegv,"Python Library Documentation: function cgegv in module numpy.lib.utils

cgegv(*args, **kwds)
    `cgegv` is deprecated!
    The `*gegv` family of routines has been deprecated in
    LAPACK 3.6.0 in favor of the `*ggev` family of routines.
    The corresponding wrappers will be removed from SciPy in
    a future release.
    
    alpha,beta,vl,vr,info = cgegv(a,b,[compute_vl,compute_vr,lwork,overwrite_a,overwrite_b])
    
    Wrapper for ``cgegv``.
    
    Parameters
    ----------
    a : input rank-2 array('F') with bounds (n,n)
    b : input rank-2 array('F') with bounds (n,n)
    
    Other Parameters
    ----------------
    compute_vl : input int, optional
        Default: 1
    compute_vr : input int, optional
        Default: 1
    overwrite_a : input int, optional
        Default: 0
    overwrite_b : input int, optional
        Default: 0
    lwork : input int, optional
        Default: max(2*n,1)
    
    Returns
    -------
    alpha : rank-1 array('F') with bounds (n)
    beta : rank-1 array('F') with bounds (n)
    vl : rank-2 array('F') with bounds (ldvl,n)
    vr : rank-2 array('F') with bounds (ldvr,n)
    info : int
",function,"('(*args, **kwds)',)",scipy,1.1.0,scipy.linalg.lapack.cgegv,linalg.lapack,cgegv,"Python Library Documentation: function cgegv in module numpy.lib.utils

cgegv(*args, **kwds)
    `cgegv` is deprecated!
    The `*gegv` family of routines has been deprecated in
    LAPACK 3.6.0 in favor of the `*ggev` family of routines.
    The corresponding wrappers will be removed from SciPy in
    a future release.
    
    alpha,beta,vl,vr,info = cgegv(a,b,[compute_vl,compute_vr,lwork,overwrite_a,overwrite_b])
    
    Wrapper for ``cgegv``.
    
    Parameters
    ----------
    a : input rank-2 array('F') with bounds (n,n)
    b : input rank-2 array('F') with bounds (n,n)
    
    Other Parameters
    ----------------
    compute_vl : input int, optional
        Default: 1
    compute_vr : input int, optional
        Default: 1
    overwrite_a : input int, optional
        Default: 0
    overwrite_b : input int, optional
        Default: 0
    lwork : input int, optional
        Default: max(2*n,1)
    
    Returns
    -------
    alpha : rank-1 array('F') with bounds (n)
    beta : rank-1 array('F') with bounds (n)
    vl : rank-2 array('F') with bounds (ldvl,n)
    vr : rank-2 array('F') with bounds (ldvr,n)
    info : int
",function,(),(),(),(),"('(*args, **kwds)',)"
scipy,1.1.0,scipy.linalg.lapack.dgegv,linalg.lapack,dgegv,"Python Library Documentation: function dgegv in module numpy.lib.utils

dgegv(*args, **kwds)
    `dgegv` is deprecated!
    The `*gegv` family of routines has been deprecated in
    LAPACK 3.6.0 in favor of the `*ggev` family of routines.
    The corresponding wrappers will be removed from SciPy in
    a future release.
    
    alphar,alphai,beta,vl,vr,info = dgegv(a,b,[compute_vl,compute_vr,lwork,overwrite_a,overwrite_b])
    
    Wrapper for ``dgegv``.
    
    Parameters
    ----------
    a : input rank-2 array('d') with bounds (n,n)
    b : input rank-2 array('d') with bounds (n,n)
    
    Other Parameters
    ----------------
    compute_vl : input int, optional
        Default: 1
    compute_vr : input int, optional
        Default: 1
    overwrite_a : input int, optional
        Default: 0
    overwrite_b : input int, optional
        Default: 0
    lwork : input int, optional
        Default: max(8*n,1)
    
    Returns
    -------
    alphar : rank-1 array('d') with bounds (n)
    alphai : rank-1 array('d') with bounds (n)
    beta : rank-1 array('d') with bounds (n)
    vl : rank-2 array('d') with bounds (ldvl,n)
    vr : rank-2 array('d') with bounds (ldvr,n)
    info : int
",function,"('(*args, **kwds)',)",scipy,1.1.0,scipy.linalg.lapack.dgegv,linalg.lapack,dgegv,"Python Library Documentation: function dgegv in module numpy.lib.utils

dgegv(*args, **kwds)
    `dgegv` is deprecated!
    The `*gegv` family of routines has been deprecated in
    LAPACK 3.6.0 in favor of the `*ggev` family of routines.
    The corresponding wrappers will be removed from SciPy in
    a future release.
    
    alphar,alphai,beta,vl,vr,info = dgegv(a,b,[compute_vl,compute_vr,lwork,overwrite_a,overwrite_b])
    
    Wrapper for ``dgegv``.
    
    Parameters
    ----------
    a : input rank-2 array('d') with bounds (n,n)
    b : input rank-2 array('d') with bounds (n,n)
    
    Other Parameters
    ----------------
    compute_vl : input int, optional
        Default: 1
    compute_vr : input int, optional
        Default: 1
    overwrite_a : input int, optional
        Default: 0
    overwrite_b : input int, optional
        Default: 0
    lwork : input int, optional
        Default: max(8*n,1)
    
    Returns
    -------
    alphar : rank-1 array('d') with bounds (n)
    alphai : rank-1 array('d') with bounds (n)
    beta : rank-1 array('d') with bounds (n)
    vl : rank-2 array('d') with bounds (ldvl,n)
    vr : rank-2 array('d') with bounds (ldvr,n)
    info : int
",function,(),(),(),(),"('(*args, **kwds)',)"
scipy,1.1.0,scipy.linalg.lapack.find_best_lapack_type,linalg.lapack,find_best_blas_type,"Python Library Documentation: function find_best_blas_type in module scipy.linalg.blas

find_best_blas_type(arrays=(), dtype=None)
    Find best-matching BLAS/LAPACK type.
    
    Arrays are used to determine the optimal prefix of BLAS routines.
    
    Parameters
    ----------
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of BLAS
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    prefix : str
        BLAS/LAPACK prefix character.
    dtype : dtype
        Inferred Numpy data type.
    prefer_fortran : bool
        Whether to prefer Fortran order routines over C order.
    
    Examples
    --------
    >>> import scipy.linalg.blas as bla
    >>> a = np.random.rand(10,15)
    >>> b = np.asfortranarray(a)  # Change the memory layout order
    >>> bla.find_best_blas_type((a,))
    ('d', dtype('float64'), False)
    >>> bla.find_best_blas_type((a*1j,))
    ('z', dtype('complex128'), False)
    >>> bla.find_best_blas_type((b,))
    ('d', dtype('float64'), True)
",function,"('(arrays=(), dtype=None)',)",scipy,1.1.0,scipy.linalg.lapack.find_best_lapack_type,linalg.lapack,find_best_blas_type,"Python Library Documentation: function find_best_blas_type in module scipy.linalg.blas

find_best_blas_type(arrays=(), dtype=None)
    Find best-matching BLAS/LAPACK type.
    
    Arrays are used to determine the optimal prefix of BLAS routines.
    
    Parameters
    ----------
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of BLAS
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    prefix : str
        BLAS/LAPACK prefix character.
    dtype : dtype
        Inferred Numpy data type.
    prefer_fortran : bool
        Whether to prefer Fortran order routines over C order.
    
    Examples
    --------
    >>> import scipy.linalg.blas as bla
    >>> a = np.random.rand(10,15)
    >>> b = np.asfortranarray(a)  # Change the memory layout order
    >>> bla.find_best_blas_type((a,))
    ('d', dtype('float64'), False)
    >>> bla.find_best_blas_type((a*1j,))
    ('z', dtype('complex128'), False)
    >>> bla.find_best_blas_type((b,))
    ('d', dtype('float64'), True)
",function,"('arrays', 'dtype')","((), None)","('tuple', 'NoneType')","('arg_info', 'arg_info')","('(arrays=(), dtype=None)',)"
scipy,1.1.0,scipy.linalg.lapack.get_lapack_funcs,linalg.lapack,get_lapack_funcs,"Python Library Documentation: function get_lapack_funcs in module scipy.linalg.lapack

get_lapack_funcs(names, arrays=(), dtype=None)
    Return available LAPACK function objects from names.
    
    Arrays are used to determine the optimal prefix of LAPACK routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of LAPACK functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of LAPACK
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In LAPACK, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively, and
    are stored in attribute ``typecode`` of the returned functions.
    
    Examples
    --------
    Suppose we would like to use '?lange' routine which computes the selected
    norm of an array. We pass our array in order to get the correct 'lange'
    flavor.
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_lange = LA.get_lapack_funcs('lange', (a,))
    >>> x_lange.typecode
    'd'
    >>> x_lange = LA.get_lapack_funcs('lange',(a*1j,))
    >>> x_lange.typecode
    'z'
    
    Several LAPACK routines work best when its internal WORK array has
    the optimal size (big enough for fast computation and small enough to
    avoid waste of memory). This size is determined also by a dedicated query
    to the function which is often wrapped as a standalone function and
    commonly denoted as ``###_lwork``. Below is an example for ``?sysv``
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(1000,1000)
    >>> b = np.random.rand(1000,1)*1j
    >>> # We pick up zsysv and zsysv_lwork due to b array
    ... xsysv, xlwork = LA.get_lapack_funcs(('sysv', 'sysv_lwork'), (a, b))
    >>> opt_lwork, _ = xlwork(a.shape[0])  # returns a complex for 'z' prefix
    >>> udut, ipiv, x, info = xsysv(a, b, lwork=int(opt_lwork.real))
",function,"('(names, arrays=(), dtype=None)',)",scipy,1.1.0,scipy.linalg.lapack.get_lapack_funcs,linalg.lapack,get_lapack_funcs,"Python Library Documentation: function get_lapack_funcs in module scipy.linalg.lapack

get_lapack_funcs(names, arrays=(), dtype=None)
    Return available LAPACK function objects from names.
    
    Arrays are used to determine the optimal prefix of LAPACK routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of LAPACK functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of LAPACK
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In LAPACK, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively, and
    are stored in attribute ``typecode`` of the returned functions.
    
    Examples
    --------
    Suppose we would like to use '?lange' routine which computes the selected
    norm of an array. We pass our array in order to get the correct 'lange'
    flavor.
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_lange = LA.get_lapack_funcs('lange', (a,))
    >>> x_lange.typecode
    'd'
    >>> x_lange = LA.get_lapack_funcs('lange',(a*1j,))
    >>> x_lange.typecode
    'z'
    
    Several LAPACK routines work best when its internal WORK array has
    the optimal size (big enough for fast computation and small enough to
    avoid waste of memory). This size is determined also by a dedicated query
    to the function which is often wrapped as a standalone function and
    commonly denoted as ``###_lwork``. Below is an example for ``?sysv``
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(1000,1000)
    >>> b = np.random.rand(1000,1)*1j
    >>> # We pick up zsysv and zsysv_lwork due to b array
    ... xsysv, xlwork = LA.get_lapack_funcs(('sysv', 'sysv_lwork'), (a, b))
    >>> opt_lwork, _ = xlwork(a.shape[0])  # returns a complex for 'z' prefix
    >>> udut, ipiv, x, info = xsysv(a, b, lwork=int(opt_lwork.real))
",function,"('names', 'arrays', 'dtype')","(nan, (), None)","(nan, 'tuple', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(names, arrays=(), dtype=None)',)"
scipy,1.1.0,scipy.linalg.lapack.sgegv,linalg.lapack,sgegv,"Python Library Documentation: function sgegv in module numpy.lib.utils

sgegv(*args, **kwds)
    `sgegv` is deprecated!
    The `*gegv` family of routines has been deprecated in
    LAPACK 3.6.0 in favor of the `*ggev` family of routines.
    The corresponding wrappers will be removed from SciPy in
    a future release.
    
    alphar,alphai,beta,vl,vr,info = sgegv(a,b,[compute_vl,compute_vr,lwork,overwrite_a,overwrite_b])
    
    Wrapper for ``sgegv``.
    
    Parameters
    ----------
    a : input rank-2 array('f') with bounds (n,n)
    b : input rank-2 array('f') with bounds (n,n)
    
    Other Parameters
    ----------------
    compute_vl : input int, optional
        Default: 1
    compute_vr : input int, optional
        Default: 1
    overwrite_a : input int, optional
        Default: 0
    overwrite_b : input int, optional
        Default: 0
    lwork : input int, optional
        Default: max(8*n,1)
    
    Returns
    -------
    alphar : rank-1 array('f') with bounds (n)
    alphai : rank-1 array('f') with bounds (n)
    beta : rank-1 array('f') with bounds (n)
    vl : rank-2 array('f') with bounds (ldvl,n)
    vr : rank-2 array('f') with bounds (ldvr,n)
    info : int
",function,"('(*args, **kwds)',)",scipy,1.1.0,scipy.linalg.lapack.sgegv,linalg.lapack,sgegv,"Python Library Documentation: function sgegv in module numpy.lib.utils

sgegv(*args, **kwds)
    `sgegv` is deprecated!
    The `*gegv` family of routines has been deprecated in
    LAPACK 3.6.0 in favor of the `*ggev` family of routines.
    The corresponding wrappers will be removed from SciPy in
    a future release.
    
    alphar,alphai,beta,vl,vr,info = sgegv(a,b,[compute_vl,compute_vr,lwork,overwrite_a,overwrite_b])
    
    Wrapper for ``sgegv``.
    
    Parameters
    ----------
    a : input rank-2 array('f') with bounds (n,n)
    b : input rank-2 array('f') with bounds (n,n)
    
    Other Parameters
    ----------------
    compute_vl : input int, optional
        Default: 1
    compute_vr : input int, optional
        Default: 1
    overwrite_a : input int, optional
        Default: 0
    overwrite_b : input int, optional
        Default: 0
    lwork : input int, optional
        Default: max(8*n,1)
    
    Returns
    -------
    alphar : rank-1 array('f') with bounds (n)
    alphai : rank-1 array('f') with bounds (n)
    beta : rank-1 array('f') with bounds (n)
    vl : rank-2 array('f') with bounds (ldvl,n)
    vr : rank-2 array('f') with bounds (ldvr,n)
    info : int
",function,(),(),(),(),"('(*args, **kwds)',)"
scipy,1.1.0,scipy.linalg.lapack.zgegv,linalg.lapack,zgegv,"Python Library Documentation: function zgegv in module numpy.lib.utils

zgegv(*args, **kwds)
    `zgegv` is deprecated!
    The `*gegv` family of routines has been deprecated in
    LAPACK 3.6.0 in favor of the `*ggev` family of routines.
    The corresponding wrappers will be removed from SciPy in
    a future release.
    
    alpha,beta,vl,vr,info = zgegv(a,b,[compute_vl,compute_vr,lwork,overwrite_a,overwrite_b])
    
    Wrapper for ``zgegv``.
    
    Parameters
    ----------
    a : input rank-2 array('D') with bounds (n,n)
    b : input rank-2 array('D') with bounds (n,n)
    
    Other Parameters
    ----------------
    compute_vl : input int, optional
        Default: 1
    compute_vr : input int, optional
        Default: 1
    overwrite_a : input int, optional
        Default: 0
    overwrite_b : input int, optional
        Default: 0
    lwork : input int, optional
        Default: max(2*n,1)
    
    Returns
    -------
    alpha : rank-1 array('D') with bounds (n)
    beta : rank-1 array('D') with bounds (n)
    vl : rank-2 array('D') with bounds (ldvl,n)
    vr : rank-2 array('D') with bounds (ldvr,n)
    info : int
",function,"('(*args, **kwds)',)",scipy,1.1.0,scipy.linalg.lapack.zgegv,linalg.lapack,zgegv,"Python Library Documentation: function zgegv in module numpy.lib.utils

zgegv(*args, **kwds)
    `zgegv` is deprecated!
    The `*gegv` family of routines has been deprecated in
    LAPACK 3.6.0 in favor of the `*ggev` family of routines.
    The corresponding wrappers will be removed from SciPy in
    a future release.
    
    alpha,beta,vl,vr,info = zgegv(a,b,[compute_vl,compute_vr,lwork,overwrite_a,overwrite_b])
    
    Wrapper for ``zgegv``.
    
    Parameters
    ----------
    a : input rank-2 array('D') with bounds (n,n)
    b : input rank-2 array('D') with bounds (n,n)
    
    Other Parameters
    ----------------
    compute_vl : input int, optional
        Default: 1
    compute_vr : input int, optional
        Default: 1
    overwrite_a : input int, optional
        Default: 0
    overwrite_b : input int, optional
        Default: 0
    lwork : input int, optional
        Default: max(2*n,1)
    
    Returns
    -------
    alpha : rank-1 array('D') with bounds (n)
    beta : rank-1 array('D') with bounds (n)
    vl : rank-2 array('D') with bounds (ldvl,n)
    vr : rank-2 array('D') with bounds (ldvr,n)
    info : int
",function,(),(),(),(),"('(*args, **kwds)',)"
scipy,1.1.0,scipy.linalg.ldl,linalg,ldl,"Python Library Documentation: function ldl in module scipy.linalg._decomp_ldl

ldl(A, lower=True, hermitian=True, overwrite_a=False, check_finite=True)
    Computes the LDLt or Bunch-Kaufman factorization of a symmetric/
    hermitian matrix.
    
    This function returns a block diagonal matrix D consisting blocks of size
    at most 2x2 and also a possibly permuted unit lower triangular matrix
    ``L`` such that the factorization ``A = L D L^H`` or ``A = L D L^T``
    holds. If ``lower`` is False then (again possibly permuted) upper
    triangular matrices are returned as outer factors.
    
    The permutation array can be used to triangularize the outer factors
    simply by a row shuffle, i.e., ``lu[perm, :]`` is an upper/lower
    triangular matrix. This is also equivalent to multiplication with a
    permutation matrix ``P.dot(lu)`` where ``P`` is a column-permuted
    identity matrix ``I[:, perm]``.
    
    Depending on the value of the boolean ``lower``, only upper or lower
    triangular part of the input array is referenced. Hence a triangular
    matrix on entry would give the same result as if the full matrix is
    supplied.
    
    Parameters
    ----------
    a : array_like
        Square input array
    lower : bool, optional
        This switches between the lower and upper triangular outer factors of
        the factorization. Lower triangular (``lower=True``) is the default.
    hermitian : bool, optional
        For complex-valued arrays, this defines whether ``a = a.conj().T`` or
        ``a = a.T`` is assumed. For real-valued arrays, this switch has no
        effect.
    overwrite_a : bool, optional
        Allow overwriting data in ``a`` (may enhance performance). The default
        is False.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    lu : ndarray
        The (possibly) permuted upper/lower triangular outer factor of the
        factorization.
    d : ndarray
        The block diagonal multiplier of the factorization.
    perm : ndarray
        The row-permutation index array that brings lu into triangular form.
    
    Raises
    ------
    ValueError
        If input array is not square.
    ComplexWarning
        If a complex-valued array with nonzero imaginary parts on the
        diagonal is given and hermitian is set to True.
    
    Examples
    --------
    Given an upper triangular array `a` that represents the full symmetric
    array with its entries, obtain `l`, 'd' and the permutation vector `perm`:
    
    >>> import numpy as np
    >>> from scipy.linalg import ldl
    >>> a = np.array([[2, -1, 3], [0, 2, 0], [0, 0, 1]])
    >>> lu, d, perm = ldl(a, lower=0) # Use the upper part
    >>> lu
    array([[ 0. ,  0. ,  1. ],
           [ 0. ,  1. , -0.5],
           [ 1. ,  1. ,  1.5]])
    >>> d
    array([[-5. ,  0. ,  0. ],
           [ 0. ,  1.5,  0. ],
           [ 0. ,  0. ,  2. ]])
    >>> perm
    array([2, 1, 0])
    >>> lu[perm, :]
    array([[ 1. ,  1. ,  1.5],
           [ 0. ,  1. , -0.5],
           [ 0. ,  0. ,  1. ]])
    >>> lu.dot(d).dot(lu.T)
    array([[ 2., -1.,  3.],
           [-1.,  2.,  0.],
           [ 3.,  0.,  1.]])
    
    Notes
    -----
    This function uses ``?SYTRF`` routines for symmetric matrices and
    ``?HETRF`` routines for Hermitian matrices from LAPACK. See [1]_ for
    the algorithm details.
    
    Depending on the ``lower`` keyword value, only lower or upper triangular
    part of the input array is referenced. Moreover, this keyword also defines
    the structure of the outer factors of the factorization.
    
    .. versionadded:: 1.1.0
    
    See also
    --------
    cholesky, lu
    
    References
    ----------
    .. [1] J.R. Bunch, L. Kaufman, Some stable methods for calculating
       inertia and solving symmetric linear systems, Math. Comput. Vol.31,
       1977. DOI: 10.2307/2005787
",function,"('(A, lower=True, hermitian=True, overwrite_a=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.ldl,linalg,ldl,"Python Library Documentation: function ldl in module scipy.linalg._decomp_ldl

ldl(A, lower=True, hermitian=True, overwrite_a=False, check_finite=True)
    Computes the LDLt or Bunch-Kaufman factorization of a symmetric/
    hermitian matrix.
    
    This function returns a block diagonal matrix D consisting blocks of size
    at most 2x2 and also a possibly permuted unit lower triangular matrix
    ``L`` such that the factorization ``A = L D L^H`` or ``A = L D L^T``
    holds. If ``lower`` is False then (again possibly permuted) upper
    triangular matrices are returned as outer factors.
    
    The permutation array can be used to triangularize the outer factors
    simply by a row shuffle, i.e., ``lu[perm, :]`` is an upper/lower
    triangular matrix. This is also equivalent to multiplication with a
    permutation matrix ``P.dot(lu)`` where ``P`` is a column-permuted
    identity matrix ``I[:, perm]``.
    
    Depending on the value of the boolean ``lower``, only upper or lower
    triangular part of the input array is referenced. Hence a triangular
    matrix on entry would give the same result as if the full matrix is
    supplied.
    
    Parameters
    ----------
    a : array_like
        Square input array
    lower : bool, optional
        This switches between the lower and upper triangular outer factors of
        the factorization. Lower triangular (``lower=True``) is the default.
    hermitian : bool, optional
        For complex-valued arrays, this defines whether ``a = a.conj().T`` or
        ``a = a.T`` is assumed. For real-valued arrays, this switch has no
        effect.
    overwrite_a : bool, optional
        Allow overwriting data in ``a`` (may enhance performance). The default
        is False.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    lu : ndarray
        The (possibly) permuted upper/lower triangular outer factor of the
        factorization.
    d : ndarray
        The block diagonal multiplier of the factorization.
    perm : ndarray
        The row-permutation index array that brings lu into triangular form.
    
    Raises
    ------
    ValueError
        If input array is not square.
    ComplexWarning
        If a complex-valued array with nonzero imaginary parts on the
        diagonal is given and hermitian is set to True.
    
    Examples
    --------
    Given an upper triangular array `a` that represents the full symmetric
    array with its entries, obtain `l`, 'd' and the permutation vector `perm`:
    
    >>> import numpy as np
    >>> from scipy.linalg import ldl
    >>> a = np.array([[2, -1, 3], [0, 2, 0], [0, 0, 1]])
    >>> lu, d, perm = ldl(a, lower=0) # Use the upper part
    >>> lu
    array([[ 0. ,  0. ,  1. ],
           [ 0. ,  1. , -0.5],
           [ 1. ,  1. ,  1.5]])
    >>> d
    array([[-5. ,  0. ,  0. ],
           [ 0. ,  1.5,  0. ],
           [ 0. ,  0. ,  2. ]])
    >>> perm
    array([2, 1, 0])
    >>> lu[perm, :]
    array([[ 1. ,  1. ,  1.5],
           [ 0. ,  1. , -0.5],
           [ 0. ,  0. ,  1. ]])
    >>> lu.dot(d).dot(lu.T)
    array([[ 2., -1.,  3.],
           [-1.,  2.,  0.],
           [ 3.,  0.,  1.]])
    
    Notes
    -----
    This function uses ``?SYTRF`` routines for symmetric matrices and
    ``?HETRF`` routines for Hermitian matrices from LAPACK. See [1]_ for
    the algorithm details.
    
    Depending on the ``lower`` keyword value, only lower or upper triangular
    part of the input array is referenced. Moreover, this keyword also defines
    the structure of the outer factors of the factorization.
    
    .. versionadded:: 1.1.0
    
    See also
    --------
    cholesky, lu
    
    References
    ----------
    .. [1] J.R. Bunch, L. Kaufman, Some stable methods for calculating
       inertia and solving symmetric linear systems, Math. Comput. Vol.31,
       1977. DOI: 10.2307/2005787
",function,"('A', 'lower', 'hermitian', 'overwrite_a', 'check_finite')","(nan, True, True, False, True)","(nan, 'bool', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(A, lower=True, hermitian=True, overwrite_a=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.leslie,linalg,leslie,"Python Library Documentation: function leslie in module scipy.linalg.special_matrices

leslie(f, s)
    Create a Leslie matrix.
    
    Given the length n array of fecundity coefficients `f` and the length
    n-1 array of survival coefficients `s`, return the associated Leslie matrix.
    
    Parameters
    ----------
    f : (N,) array_like
        The ""fecundity"" coefficients.
    s : (N-1,) array_like
        The ""survival"" coefficients, has to be 1-D.  The length of `s`
        must be one less than the length of `f`, and it must be at least 1.
    
    Returns
    -------
    L : (N, N) ndarray
        The array is zero except for the first row,
        which is `f`, and the first sub-diagonal, which is `s`.
        The data-type of the array will be the data-type of ``f[0]+s[0]``.
    
    Notes
    -----
    .. versionadded:: 0.8.0
    
    The Leslie matrix is used to model discrete-time, age-structured
    population growth [1]_ [2]_. In a population with `n` age classes, two sets
    of parameters define a Leslie matrix: the `n` ""fecundity coefficients"",
    which give the number of offspring per-capita produced by each age
    class, and the `n` - 1 ""survival coefficients"", which give the
    per-capita survival rate of each age class.
    
    References
    ----------
    .. [1] P. H. Leslie, On the use of matrices in certain population
           mathematics, Biometrika, Vol. 33, No. 3, 183--212 (Nov. 1945)
    .. [2] P. H. Leslie, Some further notes on the use of matrices in
           population mathematics, Biometrika, Vol. 35, No. 3/4, 213--245
           (Dec. 1948)
    
    Examples
    --------
    >>> from scipy.linalg import leslie
    >>> leslie([0.1, 2.0, 1.0, 0.1], [0.2, 0.8, 0.7])
    array([[ 0.1,  2. ,  1. ,  0.1],
           [ 0.2,  0. ,  0. ,  0. ],
           [ 0. ,  0.8,  0. ,  0. ],
           [ 0. ,  0. ,  0.7,  0. ]])
",function,"('(f, s)',)",scipy,1.1.0,scipy.linalg.leslie,linalg,leslie,"Python Library Documentation: function leslie in module scipy.linalg.special_matrices

leslie(f, s)
    Create a Leslie matrix.
    
    Given the length n array of fecundity coefficients `f` and the length
    n-1 array of survival coefficients `s`, return the associated Leslie matrix.
    
    Parameters
    ----------
    f : (N,) array_like
        The ""fecundity"" coefficients.
    s : (N-1,) array_like
        The ""survival"" coefficients, has to be 1-D.  The length of `s`
        must be one less than the length of `f`, and it must be at least 1.
    
    Returns
    -------
    L : (N, N) ndarray
        The array is zero except for the first row,
        which is `f`, and the first sub-diagonal, which is `s`.
        The data-type of the array will be the data-type of ``f[0]+s[0]``.
    
    Notes
    -----
    .. versionadded:: 0.8.0
    
    The Leslie matrix is used to model discrete-time, age-structured
    population growth [1]_ [2]_. In a population with `n` age classes, two sets
    of parameters define a Leslie matrix: the `n` ""fecundity coefficients"",
    which give the number of offspring per-capita produced by each age
    class, and the `n` - 1 ""survival coefficients"", which give the
    per-capita survival rate of each age class.
    
    References
    ----------
    .. [1] P. H. Leslie, On the use of matrices in certain population
           mathematics, Biometrika, Vol. 33, No. 3, 183--212 (Nov. 1945)
    .. [2] P. H. Leslie, Some further notes on the use of matrices in
           population mathematics, Biometrika, Vol. 35, No. 3/4, 213--245
           (Dec. 1948)
    
    Examples
    --------
    >>> from scipy.linalg import leslie
    >>> leslie([0.1, 2.0, 1.0, 0.1], [0.2, 0.8, 0.7])
    array([[ 0.1,  2. ,  1. ,  0.1],
           [ 0.2,  0. ,  0. ,  0. ],
           [ 0. ,  0.8,  0. ,  0. ],
           [ 0. ,  0. ,  0.7,  0. ]])
",function,"('f', 's')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(f, s)',)"
scipy,1.1.0,scipy.linalg.logm,linalg,logm,"Python Library Documentation: function logm in module scipy.linalg.matfuncs

logm(A, disp=True)
    Compute matrix logarithm.
    
    The matrix logarithm is the inverse of
    expm: expm(logm(`A`)) == `A`
    
    Parameters
    ----------
    A : (N, N) array_like
        Matrix whose logarithm to evaluate
    disp : bool, optional
        Print warning if error in the result is estimated large
        instead of returning estimated error. (Default: True)
    
    Returns
    -------
    logm : (N, N) ndarray
        Matrix logarithm of `A`
    errest : float
        (if disp == False)
    
        1-norm of the estimated error, ||err||_1 / ||A||_1
    
    References
    ----------
    .. [1] Awad H. Al-Mohy and Nicholas J. Higham (2012)
           ""Improved Inverse Scaling and Squaring Algorithms
           for the Matrix Logarithm.""
           SIAM Journal on Scientific Computing, 34 (4). C152-C169.
           ISSN 1095-7197
    
    .. [2] Nicholas J. Higham (2008)
           ""Functions of Matrices: Theory and Computation""
           ISBN 978-0-898716-46-7
    
    .. [3] Nicholas J. Higham and Lijing lin (2011)
           ""A Schur-Pade Algorithm for Fractional Powers of a Matrix.""
           SIAM Journal on Matrix Analysis and Applications,
           32 (3). pp. 1056-1078. ISSN 0895-4798
    
    Examples
    --------
    >>> from scipy.linalg import logm, expm
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> b = logm(a)
    >>> b
    array([[-1.02571087,  2.05142174],
           [ 0.68380725,  1.02571087]])
    >>> expm(b)         # Verify expm(logm(a)) returns a
    array([[ 1.,  3.],
           [ 1.,  4.]])
",function,"('(A, disp=True)',)",scipy,1.1.0,scipy.linalg.logm,linalg,logm,"Python Library Documentation: function logm in module scipy.linalg.matfuncs

logm(A, disp=True)
    Compute matrix logarithm.
    
    The matrix logarithm is the inverse of
    expm: expm(logm(`A`)) == `A`
    
    Parameters
    ----------
    A : (N, N) array_like
        Matrix whose logarithm to evaluate
    disp : bool, optional
        Print warning if error in the result is estimated large
        instead of returning estimated error. (Default: True)
    
    Returns
    -------
    logm : (N, N) ndarray
        Matrix logarithm of `A`
    errest : float
        (if disp == False)
    
        1-norm of the estimated error, ||err||_1 / ||A||_1
    
    References
    ----------
    .. [1] Awad H. Al-Mohy and Nicholas J. Higham (2012)
           ""Improved Inverse Scaling and Squaring Algorithms
           for the Matrix Logarithm.""
           SIAM Journal on Scientific Computing, 34 (4). C152-C169.
           ISSN 1095-7197
    
    .. [2] Nicholas J. Higham (2008)
           ""Functions of Matrices: Theory and Computation""
           ISBN 978-0-898716-46-7
    
    .. [3] Nicholas J. Higham and Lijing lin (2011)
           ""A Schur-Pade Algorithm for Fractional Powers of a Matrix.""
           SIAM Journal on Matrix Analysis and Applications,
           32 (3). pp. 1056-1078. ISSN 0895-4798
    
    Examples
    --------
    >>> from scipy.linalg import logm, expm
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> b = logm(a)
    >>> b
    array([[-1.02571087,  2.05142174],
           [ 0.68380725,  1.02571087]])
    >>> expm(b)         # Verify expm(logm(a)) returns a
    array([[ 1.,  3.],
           [ 1.,  4.]])
",function,"('A', 'disp')","(nan, True)","(nan, 'bool')","('arg_info', 'arg_info')","('(A, disp=True)',)"
scipy,1.1.0,scipy.linalg.lstsq,linalg,lstsq,"Python Library Documentation: function lstsq in module scipy.linalg.basic

lstsq(a, b, cond=None, overwrite_a=False, overwrite_b=False, check_finite=True, lapack_driver=None)
    Compute least-squares solution to equation Ax = b.
    
    Compute a vector x such that the 2-norm ``|b - A x|`` is minimized.
    
    Parameters
    ----------
    a : (M, N) array_like
        Left hand side matrix (2-D array).
    b : (M,) or (M, K) array_like
        Right hand side matrix or vector (1-D or 2-D array).
    cond : float, optional
        Cutoff for 'small' singular values; used to determine effective
        rank of a. Singular values smaller than
        ``rcond * largest_singular_value`` are considered zero.
    overwrite_a : bool, optional
        Discard data in `a` (may enhance performance). Default is False.
    overwrite_b : bool, optional
        Discard data in `b` (may enhance performance). Default is False.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    lapack_driver : str, optional
        Which LAPACK driver is used to solve the least-squares problem.
        Options are ``'gelsd'``, ``'gelsy'``, ``'gelss'``. Default
        (``'gelsd'``) is a good choice.  However, ``'gelsy'`` can be slightly
        faster on many problems.  ``'gelss'`` was used historically.  It is
        generally slow but uses less memory.
    
        .. versionadded:: 0.17.0
    
    Returns
    -------
    x : (N,) or (N, K) ndarray
        Least-squares solution.  Return shape matches shape of `b`.
    residues : (0,) or () or (K,) ndarray
        Sums of residues, squared 2-norm for each column in ``b - a x``.
        If rank of matrix a is ``< N`` or ``N > M``, or ``'gelsy'`` is used,
        this is a length zero array. If b was 1-D, this is a () shape array
        (numpy scalar), otherwise the shape is (K,).
    rank : int
        Effective rank of matrix `a`.
    s : (min(M,N),) ndarray or None
        Singular values of `a`. The condition number of a is
        ``abs(s[0] / s[-1])``. None is returned when ``'gelsy'`` is used.
    
    Raises
    ------
    LinAlgError
        If computation does not converge.
    
    ValueError
        When parameters are wrong.
    
    See Also
    --------
    optimize.nnls : linear least squares with non-negativity constraint
    
    Examples
    --------
    >>> from scipy.linalg import lstsq
    >>> import matplotlib.pyplot as plt
    
    Suppose we have the following data:
    
    >>> x = np.array([1, 2.5, 3.5, 4, 5, 7, 8.5])
    >>> y = np.array([0.3, 1.1, 1.5, 2.0, 3.2, 6.6, 8.6])
    
    We want to fit a quadratic polynomial of the form ``y = a + b*x**2``
    to this data.  We first form the ""design matrix"" M, with a constant
    column of 1s and a column containing ``x**2``:
    
    >>> M = x[:, np.newaxis]**[0, 2]
    >>> M
    array([[  1.  ,   1.  ],
           [  1.  ,   6.25],
           [  1.  ,  12.25],
           [  1.  ,  16.  ],
           [  1.  ,  25.  ],
           [  1.  ,  49.  ],
           [  1.  ,  72.25]])
    
    We want to find the least-squares solution to ``M.dot(p) = y``,
    where ``p`` is a vector with length 2 that holds the parameters
    ``a`` and ``b``.
    
    >>> p, res, rnk, s = lstsq(M, y)
    >>> p
    array([ 0.20925829,  0.12013861])
    
    Plot the data and the fitted curve.
    
    >>> plt.plot(x, y, 'o', label='data')
    >>> xx = np.linspace(0, 9, 101)
    >>> yy = p[0] + p[1]*xx**2
    >>> plt.plot(xx, yy, label='least squares fit, $y = a + bx^2$')
    >>> plt.xlabel('x')
    >>> plt.ylabel('y')
    >>> plt.legend(framealpha=1, shadow=True)
    >>> plt.grid(alpha=0.25)
    >>> plt.show()
",function,"('(a, b, cond=None, overwrite_a=False, overwrite_b=False, check_finite=True, lapack_driver=None)',)",scipy,1.1.0,scipy.linalg.lstsq,linalg,lstsq,"Python Library Documentation: function lstsq in module scipy.linalg.basic

lstsq(a, b, cond=None, overwrite_a=False, overwrite_b=False, check_finite=True, lapack_driver=None)
    Compute least-squares solution to equation Ax = b.
    
    Compute a vector x such that the 2-norm ``|b - A x|`` is minimized.
    
    Parameters
    ----------
    a : (M, N) array_like
        Left hand side matrix (2-D array).
    b : (M,) or (M, K) array_like
        Right hand side matrix or vector (1-D or 2-D array).
    cond : float, optional
        Cutoff for 'small' singular values; used to determine effective
        rank of a. Singular values smaller than
        ``rcond * largest_singular_value`` are considered zero.
    overwrite_a : bool, optional
        Discard data in `a` (may enhance performance). Default is False.
    overwrite_b : bool, optional
        Discard data in `b` (may enhance performance). Default is False.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    lapack_driver : str, optional
        Which LAPACK driver is used to solve the least-squares problem.
        Options are ``'gelsd'``, ``'gelsy'``, ``'gelss'``. Default
        (``'gelsd'``) is a good choice.  However, ``'gelsy'`` can be slightly
        faster on many problems.  ``'gelss'`` was used historically.  It is
        generally slow but uses less memory.
    
        .. versionadded:: 0.17.0
    
    Returns
    -------
    x : (N,) or (N, K) ndarray
        Least-squares solution.  Return shape matches shape of `b`.
    residues : (0,) or () or (K,) ndarray
        Sums of residues, squared 2-norm for each column in ``b - a x``.
        If rank of matrix a is ``< N`` or ``N > M``, or ``'gelsy'`` is used,
        this is a length zero array. If b was 1-D, this is a () shape array
        (numpy scalar), otherwise the shape is (K,).
    rank : int
        Effective rank of matrix `a`.
    s : (min(M,N),) ndarray or None
        Singular values of `a`. The condition number of a is
        ``abs(s[0] / s[-1])``. None is returned when ``'gelsy'`` is used.
    
    Raises
    ------
    LinAlgError
        If computation does not converge.
    
    ValueError
        When parameters are wrong.
    
    See Also
    --------
    optimize.nnls : linear least squares with non-negativity constraint
    
    Examples
    --------
    >>> from scipy.linalg import lstsq
    >>> import matplotlib.pyplot as plt
    
    Suppose we have the following data:
    
    >>> x = np.array([1, 2.5, 3.5, 4, 5, 7, 8.5])
    >>> y = np.array([0.3, 1.1, 1.5, 2.0, 3.2, 6.6, 8.6])
    
    We want to fit a quadratic polynomial of the form ``y = a + b*x**2``
    to this data.  We first form the ""design matrix"" M, with a constant
    column of 1s and a column containing ``x**2``:
    
    >>> M = x[:, np.newaxis]**[0, 2]
    >>> M
    array([[  1.  ,   1.  ],
           [  1.  ,   6.25],
           [  1.  ,  12.25],
           [  1.  ,  16.  ],
           [  1.  ,  25.  ],
           [  1.  ,  49.  ],
           [  1.  ,  72.25]])
    
    We want to find the least-squares solution to ``M.dot(p) = y``,
    where ``p`` is a vector with length 2 that holds the parameters
    ``a`` and ``b``.
    
    >>> p, res, rnk, s = lstsq(M, y)
    >>> p
    array([ 0.20925829,  0.12013861])
    
    Plot the data and the fitted curve.
    
    >>> plt.plot(x, y, 'o', label='data')
    >>> xx = np.linspace(0, 9, 101)
    >>> yy = p[0] + p[1]*xx**2
    >>> plt.plot(xx, yy, label='least squares fit, $y = a + bx^2$')
    >>> plt.xlabel('x')
    >>> plt.ylabel('y')
    >>> plt.legend(framealpha=1, shadow=True)
    >>> plt.grid(alpha=0.25)
    >>> plt.show()
",function,"('a', 'b', 'cond', 'overwrite_a', 'overwrite_b', 'check_finite', 'lapack_driver')","(nan, nan, None, False, False, True, None)","(nan, nan, 'NoneType', 'bool', 'bool', 'bool', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, b, cond=None, overwrite_a=False, overwrite_b=False, check_finite=True, lapack_driver=None)',)"
scipy,1.1.0,scipy.linalg.lu,linalg,lu,"Python Library Documentation: function lu in module scipy.linalg.decomp_lu

lu(a, permute_l=False, overwrite_a=False, check_finite=True)
    Compute pivoted LU decomposition of a matrix.
    
    The decomposition is::
    
        A = P L U
    
    where P is a permutation matrix, L lower triangular with unit
    diagonal elements, and U upper triangular.
    
    Parameters
    ----------
    a : (M, N) array_like
        Array to decompose
    permute_l : bool, optional
        Perform the multiplication P*L  (Default: do not permute)
    overwrite_a : bool, optional
        Whether to overwrite data in a (may improve performance)
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    **(If permute_l == False)**
    
    p : (M, M) ndarray
        Permutation matrix
    l : (M, K) ndarray
        Lower triangular or trapezoidal matrix with unit diagonal.
        K = min(M, N)
    u : (K, N) ndarray
        Upper triangular or trapezoidal matrix
    
    **(If permute_l == True)**
    
    pl : (M, K) ndarray
        Permuted L matrix.
        K = min(M, N)
    u : (K, N) ndarray
        Upper triangular or trapezoidal matrix
    
    Notes
    -----
    This is a LU factorization routine written for Scipy.
    
    Examples
    --------
    >>> from scipy.linalg import lu
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> p, l, u = lu(A)
    >>> np.allclose(A - p @ l @ u, np.zeros((4, 4)))
    True
",function,"('(a, permute_l=False, overwrite_a=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.lu,linalg,lu,"Python Library Documentation: function lu in module scipy.linalg.decomp_lu

lu(a, permute_l=False, overwrite_a=False, check_finite=True)
    Compute pivoted LU decomposition of a matrix.
    
    The decomposition is::
    
        A = P L U
    
    where P is a permutation matrix, L lower triangular with unit
    diagonal elements, and U upper triangular.
    
    Parameters
    ----------
    a : (M, N) array_like
        Array to decompose
    permute_l : bool, optional
        Perform the multiplication P*L  (Default: do not permute)
    overwrite_a : bool, optional
        Whether to overwrite data in a (may improve performance)
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    **(If permute_l == False)**
    
    p : (M, M) ndarray
        Permutation matrix
    l : (M, K) ndarray
        Lower triangular or trapezoidal matrix with unit diagonal.
        K = min(M, N)
    u : (K, N) ndarray
        Upper triangular or trapezoidal matrix
    
    **(If permute_l == True)**
    
    pl : (M, K) ndarray
        Permuted L matrix.
        K = min(M, N)
    u : (K, N) ndarray
        Upper triangular or trapezoidal matrix
    
    Notes
    -----
    This is a LU factorization routine written for Scipy.
    
    Examples
    --------
    >>> from scipy.linalg import lu
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> p, l, u = lu(A)
    >>> np.allclose(A - p @ l @ u, np.zeros((4, 4)))
    True
",function,"('a', 'permute_l', 'overwrite_a', 'check_finite')","(nan, False, False, True)","(nan, 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, permute_l=False, overwrite_a=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.lu_factor,linalg,lu_factor,"Python Library Documentation: function lu_factor in module scipy.linalg.decomp_lu

lu_factor(a, overwrite_a=False, check_finite=True)
    Compute pivoted LU decomposition of a matrix.
    
    The decomposition is::
    
        A = P L U
    
    where P is a permutation matrix, L lower triangular with unit
    diagonal elements, and U upper triangular.
    
    Parameters
    ----------
    a : (M, M) array_like
        Matrix to decompose
    overwrite_a : bool, optional
        Whether to overwrite data in A (may increase performance)
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    lu : (N, N) ndarray
        Matrix containing U in its upper triangle, and L in its lower triangle.
        The unit diagonal elements of L are not stored.
    piv : (N,) ndarray
        Pivot indices representing the permutation matrix P:
        row i of matrix was interchanged with row piv[i].
    
    See also
    --------
    lu_solve : solve an equation system using the LU factorization of a matrix
    
    Notes
    -----
    This is a wrapper to the ``*GETRF`` routines from LAPACK.
    
    Examples
    --------
    >>> from scipy.linalg import lu_factor
    >>> from numpy import tril, triu, allclose, zeros, eye
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> lu, piv = lu_factor(A)
    >>> piv
    array([2, 2, 3, 3], dtype=int32)
    
    Convert LAPACK's ``piv`` array to NumPy index and test the permutation 
    
    >>> piv_py = [2, 0, 3, 1]
    >>> L, U = np.tril(lu, k=-1) + np.eye(4), np.triu(lu)
    >>> np.allclose(A[piv_py] - L @ U, np.zeros((4, 4)))
    True
",function,"('(a, overwrite_a=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.lu_factor,linalg,lu_factor,"Python Library Documentation: function lu_factor in module scipy.linalg.decomp_lu

lu_factor(a, overwrite_a=False, check_finite=True)
    Compute pivoted LU decomposition of a matrix.
    
    The decomposition is::
    
        A = P L U
    
    where P is a permutation matrix, L lower triangular with unit
    diagonal elements, and U upper triangular.
    
    Parameters
    ----------
    a : (M, M) array_like
        Matrix to decompose
    overwrite_a : bool, optional
        Whether to overwrite data in A (may increase performance)
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    lu : (N, N) ndarray
        Matrix containing U in its upper triangle, and L in its lower triangle.
        The unit diagonal elements of L are not stored.
    piv : (N,) ndarray
        Pivot indices representing the permutation matrix P:
        row i of matrix was interchanged with row piv[i].
    
    See also
    --------
    lu_solve : solve an equation system using the LU factorization of a matrix
    
    Notes
    -----
    This is a wrapper to the ``*GETRF`` routines from LAPACK.
    
    Examples
    --------
    >>> from scipy.linalg import lu_factor
    >>> from numpy import tril, triu, allclose, zeros, eye
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> lu, piv = lu_factor(A)
    >>> piv
    array([2, 2, 3, 3], dtype=int32)
    
    Convert LAPACK's ``piv`` array to NumPy index and test the permutation 
    
    >>> piv_py = [2, 0, 3, 1]
    >>> L, U = np.tril(lu, k=-1) + np.eye(4), np.triu(lu)
    >>> np.allclose(A[piv_py] - L @ U, np.zeros((4, 4)))
    True
",function,"('a', 'overwrite_a', 'check_finite')","(nan, False, True)","(nan, 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info')","('(a, overwrite_a=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.lu_solve,linalg,lu_solve,"Python Library Documentation: function lu_solve in module scipy.linalg.decomp_lu

lu_solve(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True)
    Solve an equation system, a x = b, given the LU factorization of a
    
    Parameters
    ----------
    (lu, piv)
        Factorization of the coefficient matrix a, as given by lu_factor
    b : array
        Right-hand side
    trans : {0, 1, 2}, optional
        Type of system to solve:
    
        =====  =========
        trans  system
        =====  =========
        0      a x   = b
        1      a^T x = b
        2      a^H x = b
        =====  =========
    overwrite_b : bool, optional
        Whether to overwrite data in b (may increase performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : array
        Solution to the system
    
    See also
    --------
    lu_factor : LU factorize a matrix
    
    Examples
    --------
    >>> from scipy.linalg import lu_factor, lu_solve
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> b = np.array([1, 1, 1, 1])
    >>> lu, piv = lu_factor(A)
    >>> x = lu_solve((lu, piv), b)
    >>> np.allclose(A @ x - b, np.zeros((4,)))
    True
",function,"('(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.lu_solve,linalg,lu_solve,"Python Library Documentation: function lu_solve in module scipy.linalg.decomp_lu

lu_solve(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True)
    Solve an equation system, a x = b, given the LU factorization of a
    
    Parameters
    ----------
    (lu, piv)
        Factorization of the coefficient matrix a, as given by lu_factor
    b : array
        Right-hand side
    trans : {0, 1, 2}, optional
        Type of system to solve:
    
        =====  =========
        trans  system
        =====  =========
        0      a x   = b
        1      a^T x = b
        2      a^H x = b
        =====  =========
    overwrite_b : bool, optional
        Whether to overwrite data in b (may increase performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : array
        Solution to the system
    
    See also
    --------
    lu_factor : LU factorize a matrix
    
    Examples
    --------
    >>> from scipy.linalg import lu_factor, lu_solve
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> b = np.array([1, 1, 1, 1])
    >>> lu, piv = lu_factor(A)
    >>> x = lu_solve((lu, piv), b)
    >>> np.allclose(A @ x - b, np.zeros((4,)))
    True
",function,"('lu_and_piv', 'b', 'trans', 'overwrite_b', 'check_finite')","(nan, nan, 0, False, True)","(nan, nan, 'int', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.matfuncs._asarray_square,linalg.matfuncs,_asarray_square,"Python Library Documentation: function _asarray_square in module scipy.linalg.matfuncs

_asarray_square(A)
    Wraps asarray with the extra requirement that the input be a square matrix.
    
    The motivation is that the matfuncs module has real functions that have
    been lifted to square matrix functions.
    
    Parameters
    ----------
    A : array_like
        A square matrix.
    
    Returns
    -------
    out : ndarray
        An ndarray copy or view or other representation of A.
",function,"('(A)',)",scipy,1.1.0,scipy.linalg.matfuncs._asarray_square,linalg.matfuncs,_asarray_square,"Python Library Documentation: function _asarray_square in module scipy.linalg.matfuncs

_asarray_square(A)
    Wraps asarray with the extra requirement that the input be a square matrix.
    
    The motivation is that the matfuncs module has real functions that have
    been lifted to square matrix functions.
    
    Parameters
    ----------
    A : array_like
        A square matrix.
    
    Returns
    -------
    out : ndarray
        An ndarray copy or view or other representation of A.
",function,"('A',)","(nan,)","(nan,)","('arg_info',)","('(A)',)"
scipy,1.1.0,scipy.linalg.matfuncs._maybe_real,linalg.matfuncs,_maybe_real,"Python Library Documentation: function _maybe_real in module scipy.linalg.matfuncs

_maybe_real(A, B, tol=None)
    Return either B or the real part of B, depending on properties of A and B.
    
    The motivation is that B has been computed as a complicated function of A,
    and B may be perturbed by negligible imaginary components.
    If A is real and B is complex with small imaginary components,
    then return a real copy of B.  The assumption in that case would be that
    the imaginary components of B are numerical artifacts.
    
    Parameters
    ----------
    A : ndarray
        Input array whose type is to be checked as real vs. complex.
    B : ndarray
        Array to be returned, possibly without its imaginary part.
    tol : float
        Absolute tolerance.
    
    Returns
    -------
    out : real or complex array
        Either the input array B or only the real part of the input array B.
",function,"('(A, B, tol=None)',)",scipy,1.1.0,scipy.linalg.matfuncs._maybe_real,linalg.matfuncs,_maybe_real,"Python Library Documentation: function _maybe_real in module scipy.linalg.matfuncs

_maybe_real(A, B, tol=None)
    Return either B or the real part of B, depending on properties of A and B.
    
    The motivation is that B has been computed as a complicated function of A,
    and B may be perturbed by negligible imaginary components.
    If A is real and B is complex with small imaginary components,
    then return a real copy of B.  The assumption in that case would be that
    the imaginary components of B are numerical artifacts.
    
    Parameters
    ----------
    A : ndarray
        Input array whose type is to be checked as real vs. complex.
    B : ndarray
        Array to be returned, possibly without its imaginary part.
    tol : float
        Absolute tolerance.
    
    Returns
    -------
    out : real or complex array
        Either the input array B or only the real part of the input array B.
",function,"('A', 'B', 'tol')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(A, B, tol=None)',)"
scipy,1.1.0,scipy.linalg.matfuncs.amax,linalg.matfuncs,amax,"Python Library Documentation: function amax in module numpy.core.fromnumeric

amax(a, axis=None, out=None, keepdims=<class 'numpy._globals._NoValue'>)
    Return the maximum of an array or maximum along an axis.
    
    Parameters
    ----------
    a : array_like
        Input data.
    axis : None or int or tuple of ints, optional
        Axis or axes along which to operate.  By default, flattened input is
        used.
    
        .. versionadded:: 1.7.0
    
        If this is a tuple of ints, the maximum is selected over multiple axes,
        instead of a single axis or all the axes as before.
    out : ndarray, optional
        Alternative output array in which to place the result.  Must
        be of the same shape and buffer length as the expected output.
        See `doc.ufuncs` (Section ""Output arguments"") for more details.
    
    keepdims : bool, optional
        If this is set to True, the axes which are reduced are left
        in the result as dimensions with size one. With this option,
        the result will broadcast correctly against the input array.
    
        If the default value is passed, then `keepdims` will not be
        passed through to the `amax` method of sub-classes of
        `ndarray`, however any non-default value will be.  If the
        sub-classes `sum` method does not implement `keepdims` any
        exceptions will be raised.
    
    Returns
    -------
    amax : ndarray or scalar
        Maximum of `a`. If `axis` is None, the result is a scalar value.
        If `axis` is given, the result is an array of dimension
        ``a.ndim - 1``.
    
    See Also
    --------
    amin :
        The minimum value of an array along a given axis, propagating any NaNs.
    nanmax :
        The maximum value of an array along a given axis, ignoring any NaNs.
    maximum :
        Element-wise maximum of two arrays, propagating any NaNs.
    fmax :
        Element-wise maximum of two arrays, ignoring any NaNs.
    argmax :
        Return the indices of the maximum values.
    
    nanmin, minimum, fmin
    
    Notes
    -----
    NaN values are propagated, that is if at least one item is NaN, the
    corresponding max value will be NaN as well. To ignore NaN values
    (MATLAB behavior), please use nanmax.
    
    Don't use `amax` for element-wise comparison of 2 arrays; when
    ``a.shape[0]`` is 2, ``maximum(a[0], a[1])`` is faster than
    ``amax(a, axis=0)``.
    
    Examples
    --------
    >>> a = np.arange(4).reshape((2,2))
    >>> a
    array([[0, 1],
           [2, 3]])
    >>> np.amax(a)           # Maximum of the flattened array
    3
    >>> np.amax(a, axis=0)   # Maxima along the first axis
    array([2, 3])
    >>> np.amax(a, axis=1)   # Maxima along the second axis
    array([1, 3])
    
    >>> b = np.arange(5, dtype=float)
    >>> b[2] = np.NaN
    >>> np.amax(b)
    nan
    >>> np.nanmax(b)
    4.0
",function,"(""(a, axis=None, out=None, keepdims=<class 'numpy._globals._NoValue'>)"",)",scipy,1.1.0,scipy.linalg.matfuncs.amax,linalg.matfuncs,amax,"Python Library Documentation: function amax in module numpy.core.fromnumeric

amax(a, axis=None, out=None, keepdims=<class 'numpy._globals._NoValue'>)
    Return the maximum of an array or maximum along an axis.
    
    Parameters
    ----------
    a : array_like
        Input data.
    axis : None or int or tuple of ints, optional
        Axis or axes along which to operate.  By default, flattened input is
        used.
    
        .. versionadded:: 1.7.0
    
        If this is a tuple of ints, the maximum is selected over multiple axes,
        instead of a single axis or all the axes as before.
    out : ndarray, optional
        Alternative output array in which to place the result.  Must
        be of the same shape and buffer length as the expected output.
        See `doc.ufuncs` (Section ""Output arguments"") for more details.
    
    keepdims : bool, optional
        If this is set to True, the axes which are reduced are left
        in the result as dimensions with size one. With this option,
        the result will broadcast correctly against the input array.
    
        If the default value is passed, then `keepdims` will not be
        passed through to the `amax` method of sub-classes of
        `ndarray`, however any non-default value will be.  If the
        sub-classes `sum` method does not implement `keepdims` any
        exceptions will be raised.
    
    Returns
    -------
    amax : ndarray or scalar
        Maximum of `a`. If `axis` is None, the result is a scalar value.
        If `axis` is given, the result is an array of dimension
        ``a.ndim - 1``.
    
    See Also
    --------
    amin :
        The minimum value of an array along a given axis, propagating any NaNs.
    nanmax :
        The maximum value of an array along a given axis, ignoring any NaNs.
    maximum :
        Element-wise maximum of two arrays, propagating any NaNs.
    fmax :
        Element-wise maximum of two arrays, ignoring any NaNs.
    argmax :
        Return the indices of the maximum values.
    
    nanmin, minimum, fmin
    
    Notes
    -----
    NaN values are propagated, that is if at least one item is NaN, the
    corresponding max value will be NaN as well. To ignore NaN values
    (MATLAB behavior), please use nanmax.
    
    Don't use `amax` for element-wise comparison of 2 arrays; when
    ``a.shape[0]`` is 2, ``maximum(a[0], a[1])`` is faster than
    ``amax(a, axis=0)``.
    
    Examples
    --------
    >>> a = np.arange(4).reshape((2,2))
    >>> a
    array([[0, 1],
           [2, 3]])
    >>> np.amax(a)           # Maximum of the flattened array
    3
    >>> np.amax(a, axis=0)   # Maxima along the first axis
    array([2, 3])
    >>> np.amax(a, axis=1)   # Maxima along the second axis
    array([1, 3])
    
    >>> b = np.arange(5, dtype=float)
    >>> b[2] = np.NaN
    >>> np.amax(b)
    nan
    >>> np.nanmax(b)
    4.0
",function,"('a', 'axis', 'out', 'keepdims')","(nan, None, None, <class 'numpy._globals._NoValue'>)","(nan, 'NoneType', 'NoneType', 'type')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a, axis=None, out=None, keepdims=<class 'numpy._globals._NoValue'>)"",)"
scipy,1.1.0,scipy.linalg.matfuncs.coshm,linalg.matfuncs,coshm,"Python Library Documentation: function coshm in module scipy.linalg.matfuncs

coshm(A)
    Compute the hyperbolic matrix cosine.
    
    This routine uses expm to compute the matrix exponentials.
    
    Parameters
    ----------
    A : (N, N) array_like
        Input array.
    
    Returns
    -------
    coshm : (N, N) ndarray
        Hyperbolic matrix cosine of `A`
    
    Examples
    --------
    >>> from scipy.linalg import tanhm, sinhm, coshm
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> c = coshm(a)
    >>> c
    array([[ 11.24592233,  38.76236492],
           [ 12.92078831,  50.00828725]])
    
    Verify tanhm(a) = sinhm(a).dot(inv(coshm(a)))
    
    >>> t = tanhm(a)
    >>> s = sinhm(a)
    >>> t - s.dot(np.linalg.inv(c))
    array([[  2.72004641e-15,   4.55191440e-15],
           [  0.00000000e+00,  -5.55111512e-16]])
",function,"('(A)',)",scipy,1.1.0,scipy.linalg.matfuncs.coshm,linalg.matfuncs,coshm,"Python Library Documentation: function coshm in module scipy.linalg.matfuncs

coshm(A)
    Compute the hyperbolic matrix cosine.
    
    This routine uses expm to compute the matrix exponentials.
    
    Parameters
    ----------
    A : (N, N) array_like
        Input array.
    
    Returns
    -------
    coshm : (N, N) ndarray
        Hyperbolic matrix cosine of `A`
    
    Examples
    --------
    >>> from scipy.linalg import tanhm, sinhm, coshm
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> c = coshm(a)
    >>> c
    array([[ 11.24592233,  38.76236492],
           [ 12.92078831,  50.00828725]])
    
    Verify tanhm(a) = sinhm(a).dot(inv(coshm(a)))
    
    >>> t = tanhm(a)
    >>> s = sinhm(a)
    >>> t - s.dot(np.linalg.inv(c))
    array([[  2.72004641e-15,   4.55191440e-15],
           [  0.00000000e+00,  -5.55111512e-16]])
",function,"('A',)","(nan,)","(nan,)","('arg_info',)","('(A)',)"
scipy,1.1.0,scipy.linalg.matfuncs.cosm,linalg.matfuncs,cosm,"Python Library Documentation: function cosm in module scipy.linalg.matfuncs

cosm(A)
    Compute the matrix cosine.
    
    This routine uses expm to compute the matrix exponentials.
    
    Parameters
    ----------
    A : (N, N) array_like
        Input array
    
    Returns
    -------
    cosm : (N, N) ndarray
        Matrix cosine of A
    
    Examples
    --------
    >>> from scipy.linalg import expm, sinm, cosm
    
    Euler's identity (exp(i*theta) = cos(theta) + i*sin(theta))
    applied to a matrix:
    
    >>> a = np.array([[1.0, 2.0], [-1.0, 3.0]])
    >>> expm(1j*a)
    array([[ 0.42645930+1.89217551j, -2.13721484-0.97811252j],
           [ 1.06860742+0.48905626j, -1.71075555+0.91406299j]])
    >>> cosm(a) + 1j*sinm(a)
    array([[ 0.42645930+1.89217551j, -2.13721484-0.97811252j],
           [ 1.06860742+0.48905626j, -1.71075555+0.91406299j]])
",function,"('(A)',)",scipy,1.1.0,scipy.linalg.matfuncs.cosm,linalg.matfuncs,cosm,"Python Library Documentation: function cosm in module scipy.linalg.matfuncs

cosm(A)
    Compute the matrix cosine.
    
    This routine uses expm to compute the matrix exponentials.
    
    Parameters
    ----------
    A : (N, N) array_like
        Input array
    
    Returns
    -------
    cosm : (N, N) ndarray
        Matrix cosine of A
    
    Examples
    --------
    >>> from scipy.linalg import expm, sinm, cosm
    
    Euler's identity (exp(i*theta) = cos(theta) + i*sin(theta))
    applied to a matrix:
    
    >>> a = np.array([[1.0, 2.0], [-1.0, 3.0]])
    >>> expm(1j*a)
    array([[ 0.42645930+1.89217551j, -2.13721484-0.97811252j],
           [ 1.06860742+0.48905626j, -1.71075555+0.91406299j]])
    >>> cosm(a) + 1j*sinm(a)
    array([[ 0.42645930+1.89217551j, -2.13721484-0.97811252j],
           [ 1.06860742+0.48905626j, -1.71075555+0.91406299j]])
",function,"('A',)","(nan,)","(nan,)","('arg_info',)","('(A)',)"
scipy,1.1.0,scipy.linalg.matfuncs.diag,linalg.matfuncs,diag,"Python Library Documentation: function diag in module numpy.lib.twodim_base

diag(v, k=0)
    Extract a diagonal or construct a diagonal array.
    
    See the more detailed documentation for ``numpy.diagonal`` if you use this
    function to extract a diagonal and wish to write to the resulting array;
    whether it returns a copy or a view depends on what version of numpy you
    are using.
    
    Parameters
    ----------
    v : array_like
        If `v` is a 2-D array, return a copy of its `k`-th diagonal.
        If `v` is a 1-D array, return a 2-D array with `v` on the `k`-th
        diagonal.
    k : int, optional
        Diagonal in question. The default is 0. Use `k>0` for diagonals
        above the main diagonal, and `k<0` for diagonals below the main
        diagonal.
    
    Returns
    -------
    out : ndarray
        The extracted diagonal or constructed diagonal array.
    
    See Also
    --------
    diagonal : Return specified diagonals.
    diagflat : Create a 2-D array with the flattened input as a diagonal.
    trace : Sum along diagonals.
    triu : Upper triangle of an array.
    tril : Lower triangle of an array.
    
    Examples
    --------
    >>> x = np.arange(9).reshape((3,3))
    >>> x
    array([[0, 1, 2],
           [3, 4, 5],
           [6, 7, 8]])
    
    >>> np.diag(x)
    array([0, 4, 8])
    >>> np.diag(x, k=1)
    array([1, 5])
    >>> np.diag(x, k=-1)
    array([3, 7])
    
    >>> np.diag(np.diag(x))
    array([[0, 0, 0],
           [0, 4, 0],
           [0, 0, 8]])
",function,"('(v, k=0)',)",scipy,1.1.0,scipy.linalg.matfuncs.diag,linalg.matfuncs,diag,"Python Library Documentation: function diag in module numpy.lib.twodim_base

diag(v, k=0)
    Extract a diagonal or construct a diagonal array.
    
    See the more detailed documentation for ``numpy.diagonal`` if you use this
    function to extract a diagonal and wish to write to the resulting array;
    whether it returns a copy or a view depends on what version of numpy you
    are using.
    
    Parameters
    ----------
    v : array_like
        If `v` is a 2-D array, return a copy of its `k`-th diagonal.
        If `v` is a 1-D array, return a 2-D array with `v` on the `k`-th
        diagonal.
    k : int, optional
        Diagonal in question. The default is 0. Use `k>0` for diagonals
        above the main diagonal, and `k<0` for diagonals below the main
        diagonal.
    
    Returns
    -------
    out : ndarray
        The extracted diagonal or constructed diagonal array.
    
    See Also
    --------
    diagonal : Return specified diagonals.
    diagflat : Create a 2-D array with the flattened input as a diagonal.
    trace : Sum along diagonals.
    triu : Upper triangle of an array.
    tril : Lower triangle of an array.
    
    Examples
    --------
    >>> x = np.arange(9).reshape((3,3))
    >>> x
    array([[0, 1, 2],
           [3, 4, 5],
           [6, 7, 8]])
    
    >>> np.diag(x)
    array([0, 4, 8])
    >>> np.diag(x, k=1)
    array([1, 5])
    >>> np.diag(x, k=-1)
    array([3, 7])
    
    >>> np.diag(np.diag(x))
    array([[0, 0, 0],
           [0, 4, 0],
           [0, 0, 8]])
",function,"('v', 'k')","(nan, 0)","(nan, 'int')","('arg_info', 'arg_info')","('(v, k=0)',)"
scipy,1.1.0,scipy.linalg.matfuncs.expm,linalg.matfuncs,expm,"Python Library Documentation: function expm in module scipy.linalg.matfuncs

expm(A)
    Compute the matrix exponential using Pade approximation.
    
    Parameters
    ----------
    A : (N, N) array_like or sparse matrix
        Matrix to be exponentiated.
    
    Returns
    -------
    expm : (N, N) ndarray
        Matrix exponential of `A`.
    
    References
    ----------
    .. [1] Awad H. Al-Mohy and Nicholas J. Higham (2009)
           ""A New Scaling and Squaring Algorithm for the Matrix Exponential.""
           SIAM Journal on Matrix Analysis and Applications.
           31 (3). pp. 970-989. ISSN 1095-7162
    
    Examples
    --------
    >>> from scipy.linalg import expm, sinm, cosm
    
    Matrix version of the formula exp(0) = 1:
    
    >>> expm(np.zeros((2,2)))
    array([[ 1.,  0.],
           [ 0.,  1.]])
    
    Euler's identity (exp(i*theta) = cos(theta) + i*sin(theta))
    applied to a matrix:
    
    >>> a = np.array([[1.0, 2.0], [-1.0, 3.0]])
    >>> expm(1j*a)
    array([[ 0.42645930+1.89217551j, -2.13721484-0.97811252j],
           [ 1.06860742+0.48905626j, -1.71075555+0.91406299j]])
    >>> cosm(a) + 1j*sinm(a)
    array([[ 0.42645930+1.89217551j, -2.13721484-0.97811252j],
           [ 1.06860742+0.48905626j, -1.71075555+0.91406299j]])
",function,"('(A)',)",scipy,1.1.0,scipy.linalg.matfuncs.expm,linalg.matfuncs,expm,"Python Library Documentation: function expm in module scipy.linalg.matfuncs

expm(A)
    Compute the matrix exponential using Pade approximation.
    
    Parameters
    ----------
    A : (N, N) array_like or sparse matrix
        Matrix to be exponentiated.
    
    Returns
    -------
    expm : (N, N) ndarray
        Matrix exponential of `A`.
    
    References
    ----------
    .. [1] Awad H. Al-Mohy and Nicholas J. Higham (2009)
           ""A New Scaling and Squaring Algorithm for the Matrix Exponential.""
           SIAM Journal on Matrix Analysis and Applications.
           31 (3). pp. 970-989. ISSN 1095-7162
    
    Examples
    --------
    >>> from scipy.linalg import expm, sinm, cosm
    
    Matrix version of the formula exp(0) = 1:
    
    >>> expm(np.zeros((2,2)))
    array([[ 1.,  0.],
           [ 0.,  1.]])
    
    Euler's identity (exp(i*theta) = cos(theta) + i*sin(theta))
    applied to a matrix:
    
    >>> a = np.array([[1.0, 2.0], [-1.0, 3.0]])
    >>> expm(1j*a)
    array([[ 0.42645930+1.89217551j, -2.13721484-0.97811252j],
           [ 1.06860742+0.48905626j, -1.71075555+0.91406299j]])
    >>> cosm(a) + 1j*sinm(a)
    array([[ 0.42645930+1.89217551j, -2.13721484-0.97811252j],
           [ 1.06860742+0.48905626j, -1.71075555+0.91406299j]])
",function,"('A',)","(nan,)","(nan,)","('arg_info',)","('(A)',)"
scipy,1.1.0,scipy.linalg.matfuncs.expm_cond,linalg.matfuncs,expm_cond,"Python Library Documentation: function expm_cond in module scipy.linalg._expm_frechet

expm_cond(A, check_finite=True)
    Relative condition number of the matrix exponential in the Frobenius norm.
    
    Parameters
    ----------
    A : 2d array_like
        Square input matrix with shape (N, N).
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    kappa : float
        The relative condition number of the matrix exponential
        in the Frobenius norm
    
    Notes
    -----
    A faster estimate for the condition number in the 1-norm
    has been published but is not yet implemented in scipy.
    
    .. versionadded:: 0.14.0
    
    See also
    --------
    expm : Compute the exponential of a matrix.
    expm_frechet : Compute the Frechet derivative of the matrix exponential.
    
    Examples
    --------
    >>> from scipy.linalg import expm_cond
    >>> A = np.array([[-0.3, 0.2, 0.6], [0.6, 0.3, -0.1], [-0.7, 1.2, 0.9]])
    >>> k = expm_cond(A)
    >>> k
    1.7787805864469866
",function,"('(A, check_finite=True)',)",scipy,1.1.0,scipy.linalg.matfuncs.expm_cond,linalg.matfuncs,expm_cond,"Python Library Documentation: function expm_cond in module scipy.linalg._expm_frechet

expm_cond(A, check_finite=True)
    Relative condition number of the matrix exponential in the Frobenius norm.
    
    Parameters
    ----------
    A : 2d array_like
        Square input matrix with shape (N, N).
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    kappa : float
        The relative condition number of the matrix exponential
        in the Frobenius norm
    
    Notes
    -----
    A faster estimate for the condition number in the 1-norm
    has been published but is not yet implemented in scipy.
    
    .. versionadded:: 0.14.0
    
    See also
    --------
    expm : Compute the exponential of a matrix.
    expm_frechet : Compute the Frechet derivative of the matrix exponential.
    
    Examples
    --------
    >>> from scipy.linalg import expm_cond
    >>> A = np.array([[-0.3, 0.2, 0.6], [0.6, 0.3, -0.1], [-0.7, 1.2, 0.9]])
    >>> k = expm_cond(A)
    >>> k
    1.7787805864469866
",function,"('A', 'check_finite')","(nan, True)","(nan, 'bool')","('arg_info', 'arg_info')","('(A, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.matfuncs.expm_frechet,linalg.matfuncs,expm_frechet,"Python Library Documentation: function expm_frechet in module scipy.linalg._expm_frechet

expm_frechet(A, E, method=None, compute_expm=True, check_finite=True)
    Frechet derivative of the matrix exponential of A in the direction E.
    
    Parameters
    ----------
    A : (N, N) array_like
        Matrix of which to take the matrix exponential.
    E : (N, N) array_like
        Matrix direction in which to take the Frechet derivative.
    method : str, optional
        Choice of algorithm.  Should be one of
    
        - `SPS` (default)
        - `blockEnlarge`
    
    compute_expm : bool, optional
        Whether to compute also `expm_A` in addition to `expm_frechet_AE`.
        Default is True.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    expm_A : ndarray
        Matrix exponential of A.
    expm_frechet_AE : ndarray
        Frechet derivative of the matrix exponential of A in the direction E.
    
    For ``compute_expm = False``, only `expm_frechet_AE` is returned.
    
    See also
    --------
    expm : Compute the exponential of a matrix.
    
    Notes
    -----
    This section describes the available implementations that can be selected
    by the `method` parameter. The default method is *SPS*.
    
    Method *blockEnlarge* is a naive algorithm.
    
    Method *SPS* is Scaling-Pade-Squaring [1]_.
    It is a sophisticated implementation which should take
    only about 3/8 as much time as the naive implementation.
    The asymptotics are the same.
    
    .. versionadded:: 0.13.0
    
    References
    ----------
    .. [1] Awad H. Al-Mohy and Nicholas J. Higham (2009)
           Computing the Frechet Derivative of the Matrix Exponential,
           with an application to Condition Number Estimation.
           SIAM Journal On Matrix Analysis and Applications.,
           30 (4). pp. 1639-1657. ISSN 1095-7162
    
    Examples
    --------
    >>> import scipy.linalg
    >>> A = np.random.randn(3, 3)
    >>> E = np.random.randn(3, 3)
    >>> expm_A, expm_frechet_AE = scipy.linalg.expm_frechet(A, E)
    >>> expm_A.shape, expm_frechet_AE.shape
    ((3, 3), (3, 3))
    
    >>> import scipy.linalg
    >>> A = np.random.randn(3, 3)
    >>> E = np.random.randn(3, 3)
    >>> expm_A, expm_frechet_AE = scipy.linalg.expm_frechet(A, E)
    >>> M = np.zeros((6, 6))
    >>> M[:3, :3] = A; M[:3, 3:] = E; M[3:, 3:] = A
    >>> expm_M = scipy.linalg.expm(M)
    >>> np.allclose(expm_A, expm_M[:3, :3])
    True
    >>> np.allclose(expm_frechet_AE, expm_M[:3, 3:])
    True
",function,"('(A, E, method=None, compute_expm=True, check_finite=True)',)",scipy,1.1.0,scipy.linalg.matfuncs.expm_frechet,linalg.matfuncs,expm_frechet,"Python Library Documentation: function expm_frechet in module scipy.linalg._expm_frechet

expm_frechet(A, E, method=None, compute_expm=True, check_finite=True)
    Frechet derivative of the matrix exponential of A in the direction E.
    
    Parameters
    ----------
    A : (N, N) array_like
        Matrix of which to take the matrix exponential.
    E : (N, N) array_like
        Matrix direction in which to take the Frechet derivative.
    method : str, optional
        Choice of algorithm.  Should be one of
    
        - `SPS` (default)
        - `blockEnlarge`
    
    compute_expm : bool, optional
        Whether to compute also `expm_A` in addition to `expm_frechet_AE`.
        Default is True.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    expm_A : ndarray
        Matrix exponential of A.
    expm_frechet_AE : ndarray
        Frechet derivative of the matrix exponential of A in the direction E.
    
    For ``compute_expm = False``, only `expm_frechet_AE` is returned.
    
    See also
    --------
    expm : Compute the exponential of a matrix.
    
    Notes
    -----
    This section describes the available implementations that can be selected
    by the `method` parameter. The default method is *SPS*.
    
    Method *blockEnlarge* is a naive algorithm.
    
    Method *SPS* is Scaling-Pade-Squaring [1]_.
    It is a sophisticated implementation which should take
    only about 3/8 as much time as the naive implementation.
    The asymptotics are the same.
    
    .. versionadded:: 0.13.0
    
    References
    ----------
    .. [1] Awad H. Al-Mohy and Nicholas J. Higham (2009)
           Computing the Frechet Derivative of the Matrix Exponential,
           with an application to Condition Number Estimation.
           SIAM Journal On Matrix Analysis and Applications.,
           30 (4). pp. 1639-1657. ISSN 1095-7162
    
    Examples
    --------
    >>> import scipy.linalg
    >>> A = np.random.randn(3, 3)
    >>> E = np.random.randn(3, 3)
    >>> expm_A, expm_frechet_AE = scipy.linalg.expm_frechet(A, E)
    >>> expm_A.shape, expm_frechet_AE.shape
    ((3, 3), (3, 3))
    
    >>> import scipy.linalg
    >>> A = np.random.randn(3, 3)
    >>> E = np.random.randn(3, 3)
    >>> expm_A, expm_frechet_AE = scipy.linalg.expm_frechet(A, E)
    >>> M = np.zeros((6, 6))
    >>> M[:3, :3] = A; M[:3, 3:] = E; M[3:, 3:] = A
    >>> expm_M = scipy.linalg.expm(M)
    >>> np.allclose(expm_A, expm_M[:3, :3])
    True
    >>> np.allclose(expm_frechet_AE, expm_M[:3, 3:])
    True
",function,"('A', 'E', 'method', 'compute_expm', 'check_finite')","(nan, nan, None, True, True)","(nan, nan, 'NoneType', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(A, E, method=None, compute_expm=True, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.matfuncs.fractional_matrix_power,linalg.matfuncs,fractional_matrix_power,"Python Library Documentation: function fractional_matrix_power in module scipy.linalg.matfuncs

fractional_matrix_power(A, t)
    Compute the fractional power of a matrix.
    
    Proceeds according to the discussion in section (6) of [1]_.
    
    Parameters
    ----------
    A : (N, N) array_like
        Matrix whose fractional power to evaluate.
    t : float
        Fractional power.
    
    Returns
    -------
    X : (N, N) array_like
        The fractional power of the matrix.
    
    References
    ----------
    .. [1] Nicholas J. Higham and Lijing lin (2011)
           ""A Schur-Pade Algorithm for Fractional Powers of a Matrix.""
           SIAM Journal on Matrix Analysis and Applications,
           32 (3). pp. 1056-1078. ISSN 0895-4798
    
    Examples
    --------
    >>> from scipy.linalg import fractional_matrix_power
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> b = fractional_matrix_power(a, 0.5)
    >>> b
    array([[ 0.75592895,  1.13389342],
           [ 0.37796447,  1.88982237]])
    >>> np.dot(b, b)      # Verify square root
    array([[ 1.,  3.],
           [ 1.,  4.]])
",function,"('(A, t)',)",scipy,1.1.0,scipy.linalg.matfuncs.fractional_matrix_power,linalg.matfuncs,fractional_matrix_power,"Python Library Documentation: function fractional_matrix_power in module scipy.linalg.matfuncs

fractional_matrix_power(A, t)
    Compute the fractional power of a matrix.
    
    Proceeds according to the discussion in section (6) of [1]_.
    
    Parameters
    ----------
    A : (N, N) array_like
        Matrix whose fractional power to evaluate.
    t : float
        Fractional power.
    
    Returns
    -------
    X : (N, N) array_like
        The fractional power of the matrix.
    
    References
    ----------
    .. [1] Nicholas J. Higham and Lijing lin (2011)
           ""A Schur-Pade Algorithm for Fractional Powers of a Matrix.""
           SIAM Journal on Matrix Analysis and Applications,
           32 (3). pp. 1056-1078. ISSN 0895-4798
    
    Examples
    --------
    >>> from scipy.linalg import fractional_matrix_power
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> b = fractional_matrix_power(a, 0.5)
    >>> b
    array([[ 0.75592895,  1.13389342],
           [ 0.37796447,  1.88982237]])
    >>> np.dot(b, b)      # Verify square root
    array([[ 1.,  3.],
           [ 1.,  4.]])
",function,"('A', 't')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(A, t)',)"
scipy,1.1.0,scipy.linalg.matfuncs.funm,linalg.matfuncs,funm,"Python Library Documentation: function funm in module scipy.linalg.matfuncs

funm(A, func, disp=True)
    Evaluate a matrix function specified by a callable.
    
    Returns the value of matrix-valued function ``f`` at `A`. The
    function ``f`` is an extension of the scalar-valued function `func`
    to matrices.
    
    Parameters
    ----------
    A : (N, N) array_like
        Matrix at which to evaluate the function
    func : callable
        Callable object that evaluates a scalar function f.
        Must be vectorized (eg. using vectorize).
    disp : bool, optional
        Print warning if error in the result is estimated large
        instead of returning estimated error. (Default: True)
    
    Returns
    -------
    funm : (N, N) ndarray
        Value of the matrix function specified by func evaluated at `A`
    errest : float
        (if disp == False)
    
        1-norm of the estimated error, ||err||_1 / ||A||_1
    
    Examples
    --------
    >>> from scipy.linalg import funm
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> funm(a, lambda x: x*x)
    array([[  4.,  15.],
           [  5.,  19.]])
    >>> a.dot(a)
    array([[  4.,  15.],
           [  5.,  19.]])
    
    Notes
    -----
    This function implements the general algorithm based on Schur decomposition
    (Algorithm 9.1.1. in [1]_).
    
    If the input matrix is known to be diagonalizable, then relying on the
    eigendecomposition is likely to be faster. For example, if your matrix is
    Hermitian, you can do
    
    >>> from scipy.linalg import eigh
    >>> def funm_herm(a, func, check_finite=False):
    ...     w, v = eigh(a, check_finite=check_finite)
    ...     ## if you further know that your matrix is positive semidefinite,
    ...     ## you can optionally guard against precision errors by doing
    ...     # w = np.maximum(w, 0)
    ...     w = func(w)
    ...     return (v * w).dot(v.conj().T)
    
    References
    ----------
    .. [1] Gene H. Golub, Charles F. van Loan, Matrix Computations 4th ed.
",function,"('(A, func, disp=True)',)",scipy,1.1.0,scipy.linalg.matfuncs.funm,linalg.matfuncs,funm,"Python Library Documentation: function funm in module scipy.linalg.matfuncs

funm(A, func, disp=True)
    Evaluate a matrix function specified by a callable.
    
    Returns the value of matrix-valued function ``f`` at `A`. The
    function ``f`` is an extension of the scalar-valued function `func`
    to matrices.
    
    Parameters
    ----------
    A : (N, N) array_like
        Matrix at which to evaluate the function
    func : callable
        Callable object that evaluates a scalar function f.
        Must be vectorized (eg. using vectorize).
    disp : bool, optional
        Print warning if error in the result is estimated large
        instead of returning estimated error. (Default: True)
    
    Returns
    -------
    funm : (N, N) ndarray
        Value of the matrix function specified by func evaluated at `A`
    errest : float
        (if disp == False)
    
        1-norm of the estimated error, ||err||_1 / ||A||_1
    
    Examples
    --------
    >>> from scipy.linalg import funm
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> funm(a, lambda x: x*x)
    array([[  4.,  15.],
           [  5.,  19.]])
    >>> a.dot(a)
    array([[  4.,  15.],
           [  5.,  19.]])
    
    Notes
    -----
    This function implements the general algorithm based on Schur decomposition
    (Algorithm 9.1.1. in [1]_).
    
    If the input matrix is known to be diagonalizable, then relying on the
    eigendecomposition is likely to be faster. For example, if your matrix is
    Hermitian, you can do
    
    >>> from scipy.linalg import eigh
    >>> def funm_herm(a, func, check_finite=False):
    ...     w, v = eigh(a, check_finite=check_finite)
    ...     ## if you further know that your matrix is positive semidefinite,
    ...     ## you can optionally guard against precision errors by doing
    ...     # w = np.maximum(w, 0)
    ...     w = func(w)
    ...     return (v * w).dot(v.conj().T)
    
    References
    ----------
    .. [1] Gene H. Golub, Charles F. van Loan, Matrix Computations 4th ed.
",function,"('A', 'func', 'disp')","(nan, nan, True)","(nan, nan, 'bool')","('arg_info', 'arg_info', 'arg_info')","('(A, func, disp=True)',)"
scipy,1.1.0,scipy.linalg.matfuncs.inv,linalg.matfuncs,inv,"Python Library Documentation: function inv in module scipy.linalg.basic

inv(a, overwrite_a=False, check_finite=True)
    Compute the inverse of a matrix.
    
    Parameters
    ----------
    a : array_like
        Square matrix to be inverted.
    overwrite_a : bool, optional
        Discard data in `a` (may improve performance). Default is False.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    ainv : ndarray
        Inverse of the matrix `a`.
    
    Raises
    ------
    LinAlgError
        If `a` is singular.
    ValueError
        If `a` is not square, or not 2-dimensional.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.array([[1., 2.], [3., 4.]])
    >>> linalg.inv(a)
    array([[-2. ,  1. ],
           [ 1.5, -0.5]])
    >>> np.dot(a, linalg.inv(a))
    array([[ 1.,  0.],
           [ 0.,  1.]])
",function,"('(a, overwrite_a=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.matfuncs.inv,linalg.matfuncs,inv,"Python Library Documentation: function inv in module scipy.linalg.basic

inv(a, overwrite_a=False, check_finite=True)
    Compute the inverse of a matrix.
    
    Parameters
    ----------
    a : array_like
        Square matrix to be inverted.
    overwrite_a : bool, optional
        Discard data in `a` (may improve performance). Default is False.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    ainv : ndarray
        Inverse of the matrix `a`.
    
    Raises
    ------
    LinAlgError
        If `a` is singular.
    ValueError
        If `a` is not square, or not 2-dimensional.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.array([[1., 2.], [3., 4.]])
    >>> linalg.inv(a)
    array([[-2. ,  1. ],
           [ 1.5, -0.5]])
    >>> np.dot(a, linalg.inv(a))
    array([[ 1.,  0.],
           [ 0.,  1.]])
",function,"('a', 'overwrite_a', 'check_finite')","(nan, False, True)","(nan, 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info')","('(a, overwrite_a=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.matfuncs.logm,linalg.matfuncs,logm,"Python Library Documentation: function logm in module scipy.linalg.matfuncs

logm(A, disp=True)
    Compute matrix logarithm.
    
    The matrix logarithm is the inverse of
    expm: expm(logm(`A`)) == `A`
    
    Parameters
    ----------
    A : (N, N) array_like
        Matrix whose logarithm to evaluate
    disp : bool, optional
        Print warning if error in the result is estimated large
        instead of returning estimated error. (Default: True)
    
    Returns
    -------
    logm : (N, N) ndarray
        Matrix logarithm of `A`
    errest : float
        (if disp == False)
    
        1-norm of the estimated error, ||err||_1 / ||A||_1
    
    References
    ----------
    .. [1] Awad H. Al-Mohy and Nicholas J. Higham (2012)
           ""Improved Inverse Scaling and Squaring Algorithms
           for the Matrix Logarithm.""
           SIAM Journal on Scientific Computing, 34 (4). C152-C169.
           ISSN 1095-7197
    
    .. [2] Nicholas J. Higham (2008)
           ""Functions of Matrices: Theory and Computation""
           ISBN 978-0-898716-46-7
    
    .. [3] Nicholas J. Higham and Lijing lin (2011)
           ""A Schur-Pade Algorithm for Fractional Powers of a Matrix.""
           SIAM Journal on Matrix Analysis and Applications,
           32 (3). pp. 1056-1078. ISSN 0895-4798
    
    Examples
    --------
    >>> from scipy.linalg import logm, expm
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> b = logm(a)
    >>> b
    array([[-1.02571087,  2.05142174],
           [ 0.68380725,  1.02571087]])
    >>> expm(b)         # Verify expm(logm(a)) returns a
    array([[ 1.,  3.],
           [ 1.,  4.]])
",function,"('(A, disp=True)',)",scipy,1.1.0,scipy.linalg.matfuncs.logm,linalg.matfuncs,logm,"Python Library Documentation: function logm in module scipy.linalg.matfuncs

logm(A, disp=True)
    Compute matrix logarithm.
    
    The matrix logarithm is the inverse of
    expm: expm(logm(`A`)) == `A`
    
    Parameters
    ----------
    A : (N, N) array_like
        Matrix whose logarithm to evaluate
    disp : bool, optional
        Print warning if error in the result is estimated large
        instead of returning estimated error. (Default: True)
    
    Returns
    -------
    logm : (N, N) ndarray
        Matrix logarithm of `A`
    errest : float
        (if disp == False)
    
        1-norm of the estimated error, ||err||_1 / ||A||_1
    
    References
    ----------
    .. [1] Awad H. Al-Mohy and Nicholas J. Higham (2012)
           ""Improved Inverse Scaling and Squaring Algorithms
           for the Matrix Logarithm.""
           SIAM Journal on Scientific Computing, 34 (4). C152-C169.
           ISSN 1095-7197
    
    .. [2] Nicholas J. Higham (2008)
           ""Functions of Matrices: Theory and Computation""
           ISBN 978-0-898716-46-7
    
    .. [3] Nicholas J. Higham and Lijing lin (2011)
           ""A Schur-Pade Algorithm for Fractional Powers of a Matrix.""
           SIAM Journal on Matrix Analysis and Applications,
           32 (3). pp. 1056-1078. ISSN 0895-4798
    
    Examples
    --------
    >>> from scipy.linalg import logm, expm
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> b = logm(a)
    >>> b
    array([[-1.02571087,  2.05142174],
           [ 0.68380725,  1.02571087]])
    >>> expm(b)         # Verify expm(logm(a)) returns a
    array([[ 1.,  3.],
           [ 1.,  4.]])
",function,"('A', 'disp')","(nan, True)","(nan, 'bool')","('arg_info', 'arg_info')","('(A, disp=True)',)"
scipy,1.1.0,scipy.linalg.matfuncs.norm,linalg.matfuncs,norm,"Python Library Documentation: function norm in module scipy.linalg.misc

norm(a, ord=None, axis=None, keepdims=False)
    Matrix or vector norm.
    
    This function is able to return one of seven different matrix norms,
    or one of an infinite number of vector norms (described below), depending
    on the value of the ``ord`` parameter.
    
    Parameters
    ----------
    a : (M,) or (M, N) array_like
        Input array.  If `axis` is None, `a` must be 1-D or 2-D.
    ord : {non-zero int, inf, -inf, 'fro'}, optional
        Order of the norm (see table under ``Notes``). inf means numpy's
        `inf` object
    axis : {int, 2-tuple of ints, None}, optional
        If `axis` is an integer, it specifies the axis of `a` along which to
        compute the vector norms.  If `axis` is a 2-tuple, it specifies the
        axes that hold 2-D matrices, and the matrix norms of these matrices
        are computed.  If `axis` is None then either a vector norm (when `a`
        is 1-D) or a matrix norm (when `a` is 2-D) is returned.
    keepdims : bool, optional
        If this is set to True, the axes which are normed over are left in the
        result as dimensions with size one.  With this option the result will
        broadcast correctly against the original `a`.
    
    Returns
    -------
    n : float or ndarray
        Norm of the matrix or vector(s).
    
    Notes
    -----
    For values of ``ord <= 0``, the result is, strictly speaking, not a
    mathematical 'norm', but it may still be useful for various numerical
    purposes.
    
    The following norms can be calculated:
    
    =====  ============================  ==========================
    ord    norm for matrices             norm for vectors
    =====  ============================  ==========================
    None   Frobenius norm                2-norm
    'fro'  Frobenius norm                --
    inf    max(sum(abs(x), axis=1))      max(abs(x))
    -inf   min(sum(abs(x), axis=1))      min(abs(x))
    0      --                            sum(x != 0)
    1      max(sum(abs(x), axis=0))      as below
    -1     min(sum(abs(x), axis=0))      as below
    2      2-norm (largest sing. value)  as below
    -2     smallest singular value       as below
    other  --                            sum(abs(x)**ord)**(1./ord)
    =====  ============================  ==========================
    
    The Frobenius norm is given by [1]_:
    
        :math:`||A||_F = [\sum_{i,j} abs(a_{i,j})^2]^{1/2}`
    
    The ``axis`` and ``keepdims`` arguments are passed directly to
    ``numpy.linalg.norm`` and are only usable if they are supported
    by the version of numpy in use.
    
    References
    ----------
    .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*,
           Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15
    
    Examples
    --------
    >>> from scipy.linalg import norm
    >>> a = np.arange(9) - 4.0
    >>> a
    array([-4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.])
    >>> b = a.reshape((3, 3))
    >>> b
    array([[-4., -3., -2.],
           [-1.,  0.,  1.],
           [ 2.,  3.,  4.]])
    
    >>> norm(a)
    7.745966692414834
    >>> norm(b)
    7.745966692414834
    >>> norm(b, 'fro')
    7.745966692414834
    >>> norm(a, np.inf)
    4
    >>> norm(b, np.inf)
    9
    >>> norm(a, -np.inf)
    0
    >>> norm(b, -np.inf)
    2
    
    >>> norm(a, 1)
    20
    >>> norm(b, 1)
    7
    >>> norm(a, -1)
    -4.6566128774142013e-010
    >>> norm(b, -1)
    6
    >>> norm(a, 2)
    7.745966692414834
    >>> norm(b, 2)
    7.3484692283495345
    
    >>> norm(a, -2)
    0
    >>> norm(b, -2)
    1.8570331885190563e-016
    >>> norm(a, 3)
    5.8480354764257312
    >>> norm(a, -3)
    0
",function,"('(a, ord=None, axis=None, keepdims=False)',)",scipy,1.1.0,scipy.linalg.matfuncs.norm,linalg.matfuncs,norm,"Python Library Documentation: function norm in module scipy.linalg.misc

norm(a, ord=None, axis=None, keepdims=False)
    Matrix or vector norm.
    
    This function is able to return one of seven different matrix norms,
    or one of an infinite number of vector norms (described below), depending
    on the value of the ``ord`` parameter.
    
    Parameters
    ----------
    a : (M,) or (M, N) array_like
        Input array.  If `axis` is None, `a` must be 1-D or 2-D.
    ord : {non-zero int, inf, -inf, 'fro'}, optional
        Order of the norm (see table under ``Notes``). inf means numpy's
        `inf` object
    axis : {int, 2-tuple of ints, None}, optional
        If `axis` is an integer, it specifies the axis of `a` along which to
        compute the vector norms.  If `axis` is a 2-tuple, it specifies the
        axes that hold 2-D matrices, and the matrix norms of these matrices
        are computed.  If `axis` is None then either a vector norm (when `a`
        is 1-D) or a matrix norm (when `a` is 2-D) is returned.
    keepdims : bool, optional
        If this is set to True, the axes which are normed over are left in the
        result as dimensions with size one.  With this option the result will
        broadcast correctly against the original `a`.
    
    Returns
    -------
    n : float or ndarray
        Norm of the matrix or vector(s).
    
    Notes
    -----
    For values of ``ord <= 0``, the result is, strictly speaking, not a
    mathematical 'norm', but it may still be useful for various numerical
    purposes.
    
    The following norms can be calculated:
    
    =====  ============================  ==========================
    ord    norm for matrices             norm for vectors
    =====  ============================  ==========================
    None   Frobenius norm                2-norm
    'fro'  Frobenius norm                --
    inf    max(sum(abs(x), axis=1))      max(abs(x))
    -inf   min(sum(abs(x), axis=1))      min(abs(x))
    0      --                            sum(x != 0)
    1      max(sum(abs(x), axis=0))      as below
    -1     min(sum(abs(x), axis=0))      as below
    2      2-norm (largest sing. value)  as below
    -2     smallest singular value       as below
    other  --                            sum(abs(x)**ord)**(1./ord)
    =====  ============================  ==========================
    
    The Frobenius norm is given by [1]_:
    
        :math:`||A||_F = [\sum_{i,j} abs(a_{i,j})^2]^{1/2}`
    
    The ``axis`` and ``keepdims`` arguments are passed directly to
    ``numpy.linalg.norm`` and are only usable if they are supported
    by the version of numpy in use.
    
    References
    ----------
    .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*,
           Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15
    
    Examples
    --------
    >>> from scipy.linalg import norm
    >>> a = np.arange(9) - 4.0
    >>> a
    array([-4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.])
    >>> b = a.reshape((3, 3))
    >>> b
    array([[-4., -3., -2.],
           [-1.,  0.,  1.],
           [ 2.,  3.,  4.]])
    
    >>> norm(a)
    7.745966692414834
    >>> norm(b)
    7.745966692414834
    >>> norm(b, 'fro')
    7.745966692414834
    >>> norm(a, np.inf)
    4
    >>> norm(b, np.inf)
    9
    >>> norm(a, -np.inf)
    0
    >>> norm(b, -np.inf)
    2
    
    >>> norm(a, 1)
    20
    >>> norm(b, 1)
    7
    >>> norm(a, -1)
    -4.6566128774142013e-010
    >>> norm(b, -1)
    6
    >>> norm(a, 2)
    7.745966692414834
    >>> norm(b, 2)
    7.3484692283495345
    
    >>> norm(a, -2)
    0
    >>> norm(b, -2)
    1.8570331885190563e-016
    >>> norm(a, 3)
    5.8480354764257312
    >>> norm(a, -3)
    0
",function,"('a', 'ord', 'axis', 'keepdims')","(nan, None, None, False)","(nan, 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, ord=None, axis=None, keepdims=False)',)"
scipy,1.1.0,scipy.linalg.matfuncs.product,linalg.matfuncs,product,"Python Library Documentation: function product in module numpy.core.fromnumeric

product(a, axis=None, dtype=None, out=None, keepdims=<class 'numpy._globals._NoValue'>)
    Return the product of array elements over a given axis.
    
    See Also
    --------
    prod : equivalent function; see for details.
",function,"(""(a, axis=None, dtype=None, out=None, keepdims=<class 'numpy._globals._NoValue'>)"",)",scipy,1.1.0,scipy.linalg.matfuncs.product,linalg.matfuncs,product,"Python Library Documentation: function product in module numpy.core.fromnumeric

product(a, axis=None, dtype=None, out=None, keepdims=<class 'numpy._globals._NoValue'>)
    Return the product of array elements over a given axis.
    
    See Also
    --------
    prod : equivalent function; see for details.
",function,"('a', 'axis', 'dtype', 'out', 'keepdims')","(nan, None, None, None, <class 'numpy._globals._NoValue'>)","(nan, 'NoneType', 'NoneType', 'NoneType', 'type')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a, axis=None, dtype=None, out=None, keepdims=<class 'numpy._globals._NoValue'>)"",)"
scipy,1.1.0,scipy.linalg.matfuncs.ravel,linalg.matfuncs,ravel,"Python Library Documentation: function ravel in module numpy.core.fromnumeric

ravel(a, order='C')
    Return a contiguous flattened array.
    
    A 1-D array, containing the elements of the input, is returned.  A copy is
    made only if needed.
    
    As of NumPy 1.10, the returned array will have the same type as the input
    array. (for example, a masked array will be returned for a masked array
    input)
    
    Parameters
    ----------
    a : array_like
        Input array.  The elements in `a` are read in the order specified by
        `order`, and packed as a 1-D array.
    order : {'C','F', 'A', 'K'}, optional
    
        The elements of `a` are read using this index order. 'C' means
        to index the elements in row-major, C-style order,
        with the last axis index changing fastest, back to the first
        axis index changing slowest.  'F' means to index the elements
        in column-major, Fortran-style order, with the
        first index changing fastest, and the last index changing
        slowest. Note that the 'C' and 'F' options take no account of
        the memory layout of the underlying array, and only refer to
        the order of axis indexing.  'A' means to read the elements in
        Fortran-like index order if `a` is Fortran *contiguous* in
        memory, C-like order otherwise.  'K' means to read the
        elements in the order they occur in memory, except for
        reversing the data when strides are negative.  By default, 'C'
        index order is used.
    
    Returns
    -------
    y : array_like
        If `a` is a matrix, y is a 1-D ndarray, otherwise y is an array of
        the same subtype as `a`. The shape of the returned array is
        ``(a.size,)``. Matrices are special cased for backward
        compatibility.
    
    See Also
    --------
    ndarray.flat : 1-D iterator over an array.
    ndarray.flatten : 1-D array copy of the elements of an array
                      in row-major order.
    ndarray.reshape : Change the shape of an array without changing its data.
    
    Notes
    -----
    In row-major, C-style order, in two dimensions, the row index
    varies the slowest, and the column index the quickest.  This can
    be generalized to multiple dimensions, where row-major order
    implies that the index along the first axis varies slowest, and
    the index along the last quickest.  The opposite holds for
    column-major, Fortran-style index ordering.
    
    When a view is desired in as many cases as possible, ``arr.reshape(-1)``
    may be preferable.
    
    Examples
    --------
    It is equivalent to ``reshape(-1, order=order)``.
    
    >>> x = np.array([[1, 2, 3], [4, 5, 6]])
    >>> print(np.ravel(x))
    [1 2 3 4 5 6]
    
    >>> print(x.reshape(-1))
    [1 2 3 4 5 6]
    
    >>> print(np.ravel(x, order='F'))
    [1 4 2 5 3 6]
    
    When ``order`` is 'A', it will preserve the array's 'C' or 'F' ordering:
    
    >>> print(np.ravel(x.T))
    [1 4 2 5 3 6]
    >>> print(np.ravel(x.T, order='A'))
    [1 2 3 4 5 6]
    
    When ``order`` is 'K', it will preserve orderings that are neither 'C'
    nor 'F', but won't reverse axes:
    
    >>> a = np.arange(3)[::-1]; a
    array([2, 1, 0])
    >>> a.ravel(order='C')
    array([2, 1, 0])
    >>> a.ravel(order='K')
    array([2, 1, 0])
    
    >>> a = np.arange(12).reshape(2,3,2).swapaxes(1,2); a
    array([[[ 0,  2,  4],
            [ 1,  3,  5]],
           [[ 6,  8, 10],
            [ 7,  9, 11]]])
    >>> a.ravel(order='C')
    array([ 0,  2,  4,  1,  3,  5,  6,  8, 10,  7,  9, 11])
    >>> a.ravel(order='K')
    array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
",function,"(""(a, order='C')"",)",scipy,1.1.0,scipy.linalg.matfuncs.ravel,linalg.matfuncs,ravel,"Python Library Documentation: function ravel in module numpy.core.fromnumeric

ravel(a, order='C')
    Return a contiguous flattened array.
    
    A 1-D array, containing the elements of the input, is returned.  A copy is
    made only if needed.
    
    As of NumPy 1.10, the returned array will have the same type as the input
    array. (for example, a masked array will be returned for a masked array
    input)
    
    Parameters
    ----------
    a : array_like
        Input array.  The elements in `a` are read in the order specified by
        `order`, and packed as a 1-D array.
    order : {'C','F', 'A', 'K'}, optional
    
        The elements of `a` are read using this index order. 'C' means
        to index the elements in row-major, C-style order,
        with the last axis index changing fastest, back to the first
        axis index changing slowest.  'F' means to index the elements
        in column-major, Fortran-style order, with the
        first index changing fastest, and the last index changing
        slowest. Note that the 'C' and 'F' options take no account of
        the memory layout of the underlying array, and only refer to
        the order of axis indexing.  'A' means to read the elements in
        Fortran-like index order if `a` is Fortran *contiguous* in
        memory, C-like order otherwise.  'K' means to read the
        elements in the order they occur in memory, except for
        reversing the data when strides are negative.  By default, 'C'
        index order is used.
    
    Returns
    -------
    y : array_like
        If `a` is a matrix, y is a 1-D ndarray, otherwise y is an array of
        the same subtype as `a`. The shape of the returned array is
        ``(a.size,)``. Matrices are special cased for backward
        compatibility.
    
    See Also
    --------
    ndarray.flat : 1-D iterator over an array.
    ndarray.flatten : 1-D array copy of the elements of an array
                      in row-major order.
    ndarray.reshape : Change the shape of an array without changing its data.
    
    Notes
    -----
    In row-major, C-style order, in two dimensions, the row index
    varies the slowest, and the column index the quickest.  This can
    be generalized to multiple dimensions, where row-major order
    implies that the index along the first axis varies slowest, and
    the index along the last quickest.  The opposite holds for
    column-major, Fortran-style index ordering.
    
    When a view is desired in as many cases as possible, ``arr.reshape(-1)``
    may be preferable.
    
    Examples
    --------
    It is equivalent to ``reshape(-1, order=order)``.
    
    >>> x = np.array([[1, 2, 3], [4, 5, 6]])
    >>> print(np.ravel(x))
    [1 2 3 4 5 6]
    
    >>> print(x.reshape(-1))
    [1 2 3 4 5 6]
    
    >>> print(np.ravel(x, order='F'))
    [1 4 2 5 3 6]
    
    When ``order`` is 'A', it will preserve the array's 'C' or 'F' ordering:
    
    >>> print(np.ravel(x.T))
    [1 4 2 5 3 6]
    >>> print(np.ravel(x.T, order='A'))
    [1 2 3 4 5 6]
    
    When ``order`` is 'K', it will preserve orderings that are neither 'C'
    nor 'F', but won't reverse axes:
    
    >>> a = np.arange(3)[::-1]; a
    array([2, 1, 0])
    >>> a.ravel(order='C')
    array([2, 1, 0])
    >>> a.ravel(order='K')
    array([2, 1, 0])
    
    >>> a = np.arange(12).reshape(2,3,2).swapaxes(1,2); a
    array([[[ 0,  2,  4],
            [ 1,  3,  5]],
           [[ 6,  8, 10],
            [ 7,  9, 11]]])
    >>> a.ravel(order='C')
    array([ 0,  2,  4,  1,  3,  5,  6,  8, 10,  7,  9, 11])
    >>> a.ravel(order='K')
    array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
",function,"('a', 'order')","(nan, 'C')","(nan, 'str')","('arg_info', 'arg_info')","(""(a, order='C')"",)"
scipy,1.1.0,scipy.linalg.matfuncs.rsf2csf,linalg.matfuncs,rsf2csf,"Python Library Documentation: function rsf2csf in module scipy.linalg.decomp_schur

rsf2csf(T, Z, check_finite=True)
    Convert real Schur form to complex Schur form.
    
    Convert a quasi-diagonal real-valued Schur form to the upper triangular
    complex-valued Schur form.
    
    Parameters
    ----------
    T : (M, M) array_like
        Real Schur form of the original array
    Z : (M, M) array_like
        Schur transformation matrix
    check_finite : bool, optional
        Whether to check that the input arrays contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    T : (M, M) ndarray
        Complex Schur form of the original array
    Z : (M, M) ndarray
        Schur transformation matrix corresponding to the complex form
    
    See Also
    --------
    schur : Schur decomposition of an array
    
    Examples
    --------
    >>> from scipy.linalg import schur, rsf2csf
    >>> A = np.array([[0, 2, 2], [0, 1, 2], [1, 0, 1]])
    >>> T, Z = schur(A)
    >>> T
    array([[ 2.65896708,  1.42440458, -1.92933439],
           [ 0.        , -0.32948354, -0.49063704],
           [ 0.        ,  1.31178921, -0.32948354]])
    >>> Z
    array([[0.72711591, -0.60156188, 0.33079564],
           [0.52839428, 0.79801892, 0.28976765],
           [0.43829436, 0.03590414, -0.89811411]])
    >>> T2 , Z2 = rsf2csf(T, Z)
    >>> T2
    array([[2.65896708+0.j, -1.64592781+0.743164187j, -1.21516887+1.00660462j],
           [0.+0.j , -0.32948354+8.02254558e-01j, -0.82115218-2.77555756e-17j],
           [0.+0.j , 0.+0.j, -0.32948354-0.802254558j]])
    >>> Z2
    array([[0.72711591+0.j,  0.28220393-0.31385693j,  0.51319638-0.17258824j],
           [0.52839428+0.j,  0.24720268+0.41635578j, -0.68079517-0.15118243j],
           [0.43829436+0.j, -0.76618703+0.01873251j, -0.03063006+0.46857912j]])
",function,"('(T, Z, check_finite=True)',)",scipy,1.1.0,scipy.linalg.matfuncs.rsf2csf,linalg.matfuncs,rsf2csf,"Python Library Documentation: function rsf2csf in module scipy.linalg.decomp_schur

rsf2csf(T, Z, check_finite=True)
    Convert real Schur form to complex Schur form.
    
    Convert a quasi-diagonal real-valued Schur form to the upper triangular
    complex-valued Schur form.
    
    Parameters
    ----------
    T : (M, M) array_like
        Real Schur form of the original array
    Z : (M, M) array_like
        Schur transformation matrix
    check_finite : bool, optional
        Whether to check that the input arrays contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    T : (M, M) ndarray
        Complex Schur form of the original array
    Z : (M, M) ndarray
        Schur transformation matrix corresponding to the complex form
    
    See Also
    --------
    schur : Schur decomposition of an array
    
    Examples
    --------
    >>> from scipy.linalg import schur, rsf2csf
    >>> A = np.array([[0, 2, 2], [0, 1, 2], [1, 0, 1]])
    >>> T, Z = schur(A)
    >>> T
    array([[ 2.65896708,  1.42440458, -1.92933439],
           [ 0.        , -0.32948354, -0.49063704],
           [ 0.        ,  1.31178921, -0.32948354]])
    >>> Z
    array([[0.72711591, -0.60156188, 0.33079564],
           [0.52839428, 0.79801892, 0.28976765],
           [0.43829436, 0.03590414, -0.89811411]])
    >>> T2 , Z2 = rsf2csf(T, Z)
    >>> T2
    array([[2.65896708+0.j, -1.64592781+0.743164187j, -1.21516887+1.00660462j],
           [0.+0.j , -0.32948354+8.02254558e-01j, -0.82115218-2.77555756e-17j],
           [0.+0.j , 0.+0.j, -0.32948354-0.802254558j]])
    >>> Z2
    array([[0.72711591+0.j,  0.28220393-0.31385693j,  0.51319638-0.17258824j],
           [0.52839428+0.j,  0.24720268+0.41635578j, -0.68079517-0.15118243j],
           [0.43829436+0.j, -0.76618703+0.01873251j, -0.03063006+0.46857912j]])
",function,"('T', 'Z', 'check_finite')","(nan, nan, True)","(nan, nan, 'bool')","('arg_info', 'arg_info', 'arg_info')","('(T, Z, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.matfuncs.schur,linalg.matfuncs,schur,"Python Library Documentation: function schur in module scipy.linalg.decomp_schur

schur(a, output='real', lwork=None, overwrite_a=False, sort=None, check_finite=True)
    Compute Schur decomposition of a matrix.
    
    The Schur decomposition is::
    
        A = Z T Z^H
    
    where Z is unitary and T is either upper-triangular, or for real
    Schur decomposition (output='real'), quasi-upper triangular.  In
    the quasi-triangular form, 2x2 blocks describing complex-valued
    eigenvalue pairs may extrude from the diagonal.
    
    Parameters
    ----------
    a : (M, M) array_like
        Matrix to decompose
    output : {'real', 'complex'}, optional
        Construct the real or complex Schur decomposition (for real matrices).
    lwork : int, optional
        Work array size. If None or -1, it is automatically computed.
    overwrite_a : bool, optional
        Whether to overwrite data in a (may improve performance).
    sort : {None, callable, 'lhp', 'rhp', 'iuc', 'ouc'}, optional
        Specifies whether the upper eigenvalues should be sorted.  A callable
        may be passed that, given a eigenvalue, returns a boolean denoting
        whether the eigenvalue should be sorted to the top-left (True).
        Alternatively, string parameters may be used::
    
            'lhp'   Left-hand plane (x.real < 0.0)
            'rhp'   Right-hand plane (x.real > 0.0)
            'iuc'   Inside the unit circle (x*x.conjugate() <= 1.0)
            'ouc'   Outside the unit circle (x*x.conjugate() > 1.0)
    
        Defaults to None (no sorting).
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    T : (M, M) ndarray
        Schur form of A. It is real-valued for the real Schur decomposition.
    Z : (M, M) ndarray
        An unitary Schur transformation matrix for A.
        It is real-valued for the real Schur decomposition.
    sdim : int
        If and only if sorting was requested, a third return value will
        contain the number of eigenvalues satisfying the sort condition.
    
    Raises
    ------
    LinAlgError
        Error raised under three conditions:
    
        1. The algorithm failed due to a failure of the QR algorithm to
           compute all eigenvalues
        2. If eigenvalue sorting was requested, the eigenvalues could not be
           reordered due to a failure to separate eigenvalues, usually because
           of poor conditioning
        3. If eigenvalue sorting was requested, roundoff errors caused the
           leading eigenvalues to no longer satisfy the sorting condition
    
    See also
    --------
    rsf2csf : Convert real Schur form to complex Schur form
    
    Examples
    --------
    >>> from scipy.linalg import schur, eigvals
    >>> A = np.array([[0, 2, 2], [0, 1, 2], [1, 0, 1]])
    >>> T, Z = schur(A)
    >>> T
    array([[ 2.65896708,  1.42440458, -1.92933439],
           [ 0.        , -0.32948354, -0.49063704],
           [ 0.        ,  1.31178921, -0.32948354]])
    >>> Z
    array([[0.72711591, -0.60156188, 0.33079564],
           [0.52839428, 0.79801892, 0.28976765],
           [0.43829436, 0.03590414, -0.89811411]])
    
    >>> T2, Z2 = schur(A, output='complex')
    >>> T2
    array([[ 2.65896708, -1.22839825+1.32378589j,  0.42590089+1.51937378j],
           [ 0.        , -0.32948354+0.80225456j, -0.59877807+0.56192146j],
           [ 0.        ,  0.                    , -0.32948354-0.80225456j]])
    >>> eigvals(T2)
    array([2.65896708, -0.32948354+0.80225456j, -0.32948354-0.80225456j])
    
    An arbitrary custom eig-sorting condition, having positive imaginary part, 
    which is satisfied by only one eigenvalue
    
    >>> T3, Z3, sdim = schur(A, output='complex', sort=lambda x: x.imag > 0)
    >>> sdim
    1
",function,"(""(a, output='real', lwork=None, overwrite_a=False, sort=None, check_finite=True)"",)",scipy,1.1.0,scipy.linalg.matfuncs.schur,linalg.matfuncs,schur,"Python Library Documentation: function schur in module scipy.linalg.decomp_schur

schur(a, output='real', lwork=None, overwrite_a=False, sort=None, check_finite=True)
    Compute Schur decomposition of a matrix.
    
    The Schur decomposition is::
    
        A = Z T Z^H
    
    where Z is unitary and T is either upper-triangular, or for real
    Schur decomposition (output='real'), quasi-upper triangular.  In
    the quasi-triangular form, 2x2 blocks describing complex-valued
    eigenvalue pairs may extrude from the diagonal.
    
    Parameters
    ----------
    a : (M, M) array_like
        Matrix to decompose
    output : {'real', 'complex'}, optional
        Construct the real or complex Schur decomposition (for real matrices).
    lwork : int, optional
        Work array size. If None or -1, it is automatically computed.
    overwrite_a : bool, optional
        Whether to overwrite data in a (may improve performance).
    sort : {None, callable, 'lhp', 'rhp', 'iuc', 'ouc'}, optional
        Specifies whether the upper eigenvalues should be sorted.  A callable
        may be passed that, given a eigenvalue, returns a boolean denoting
        whether the eigenvalue should be sorted to the top-left (True).
        Alternatively, string parameters may be used::
    
            'lhp'   Left-hand plane (x.real < 0.0)
            'rhp'   Right-hand plane (x.real > 0.0)
            'iuc'   Inside the unit circle (x*x.conjugate() <= 1.0)
            'ouc'   Outside the unit circle (x*x.conjugate() > 1.0)
    
        Defaults to None (no sorting).
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    T : (M, M) ndarray
        Schur form of A. It is real-valued for the real Schur decomposition.
    Z : (M, M) ndarray
        An unitary Schur transformation matrix for A.
        It is real-valued for the real Schur decomposition.
    sdim : int
        If and only if sorting was requested, a third return value will
        contain the number of eigenvalues satisfying the sort condition.
    
    Raises
    ------
    LinAlgError
        Error raised under three conditions:
    
        1. The algorithm failed due to a failure of the QR algorithm to
           compute all eigenvalues
        2. If eigenvalue sorting was requested, the eigenvalues could not be
           reordered due to a failure to separate eigenvalues, usually because
           of poor conditioning
        3. If eigenvalue sorting was requested, roundoff errors caused the
           leading eigenvalues to no longer satisfy the sorting condition
    
    See also
    --------
    rsf2csf : Convert real Schur form to complex Schur form
    
    Examples
    --------
    >>> from scipy.linalg import schur, eigvals
    >>> A = np.array([[0, 2, 2], [0, 1, 2], [1, 0, 1]])
    >>> T, Z = schur(A)
    >>> T
    array([[ 2.65896708,  1.42440458, -1.92933439],
           [ 0.        , -0.32948354, -0.49063704],
           [ 0.        ,  1.31178921, -0.32948354]])
    >>> Z
    array([[0.72711591, -0.60156188, 0.33079564],
           [0.52839428, 0.79801892, 0.28976765],
           [0.43829436, 0.03590414, -0.89811411]])
    
    >>> T2, Z2 = schur(A, output='complex')
    >>> T2
    array([[ 2.65896708, -1.22839825+1.32378589j,  0.42590089+1.51937378j],
           [ 0.        , -0.32948354+0.80225456j, -0.59877807+0.56192146j],
           [ 0.        ,  0.                    , -0.32948354-0.80225456j]])
    >>> eigvals(T2)
    array([2.65896708, -0.32948354+0.80225456j, -0.32948354-0.80225456j])
    
    An arbitrary custom eig-sorting condition, having positive imaginary part, 
    which is satisfied by only one eigenvalue
    
    >>> T3, Z3, sdim = schur(A, output='complex', sort=lambda x: x.imag > 0)
    >>> sdim
    1
",function,"('a', 'output', 'lwork', 'overwrite_a', 'sort', 'check_finite')","(nan, 'real', None, False, None, True)","(nan, 'str', 'NoneType', 'bool', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a, output='real', lwork=None, overwrite_a=False, sort=None, check_finite=True)"",)"
scipy,1.1.0,scipy.linalg.matfuncs.signm,linalg.matfuncs,signm,"Python Library Documentation: function signm in module scipy.linalg.matfuncs

signm(A, disp=True)
    Matrix sign function.
    
    Extension of the scalar sign(x) to matrices.
    
    Parameters
    ----------
    A : (N, N) array_like
        Matrix at which to evaluate the sign function
    disp : bool, optional
        Print warning if error in the result is estimated large
        instead of returning estimated error. (Default: True)
    
    Returns
    -------
    signm : (N, N) ndarray
        Value of the sign function at `A`
    errest : float
        (if disp == False)
    
        1-norm of the estimated error, ||err||_1 / ||A||_1
    
    Examples
    --------
    >>> from scipy.linalg import signm, eigvals
    >>> a = [[1,2,3], [1,2,1], [1,1,1]]
    >>> eigvals(a)
    array([ 4.12488542+0.j, -0.76155718+0.j,  0.63667176+0.j])
    >>> eigvals(signm(a))
    array([-1.+0.j,  1.+0.j,  1.+0.j])
",function,"('(A, disp=True)',)",scipy,1.1.0,scipy.linalg.matfuncs.signm,linalg.matfuncs,signm,"Python Library Documentation: function signm in module scipy.linalg.matfuncs

signm(A, disp=True)
    Matrix sign function.
    
    Extension of the scalar sign(x) to matrices.
    
    Parameters
    ----------
    A : (N, N) array_like
        Matrix at which to evaluate the sign function
    disp : bool, optional
        Print warning if error in the result is estimated large
        instead of returning estimated error. (Default: True)
    
    Returns
    -------
    signm : (N, N) ndarray
        Value of the sign function at `A`
    errest : float
        (if disp == False)
    
        1-norm of the estimated error, ||err||_1 / ||A||_1
    
    Examples
    --------
    >>> from scipy.linalg import signm, eigvals
    >>> a = [[1,2,3], [1,2,1], [1,1,1]]
    >>> eigvals(a)
    array([ 4.12488542+0.j, -0.76155718+0.j,  0.63667176+0.j])
    >>> eigvals(signm(a))
    array([-1.+0.j,  1.+0.j,  1.+0.j])
",function,"('A', 'disp')","(nan, True)","(nan, 'bool')","('arg_info', 'arg_info')","('(A, disp=True)',)"
scipy,1.1.0,scipy.linalg.matfuncs.single,linalg.matfuncs,float32,"Python Library Documentation: class float32 in module numpy

class float32(floating)
 |  32-bit floating-point number. Character code 'f'. C float compatible.
 |  
 |  Method resolution order:
 |      float32
 |      floating
 |      inexact
 |      number
 |      generic
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from generic:
 |  
 |  __array__(...)
 |      sc.__array__(|type) return 0-dim array
 |  
 |  __array_wrap__(...)
 |      sc.__array_wrap__(obj) return scalar from array
 |  
 |  __copy__(...)
 |  
 |  __deepcopy__(...)
 |  
 |  __format__(...)
 |      NumPy array scalar formatter
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __round__(...)
 |  
 |  __setstate__(...)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  all(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  any(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmax(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmin(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argsort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  astype(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  byteswap(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  choose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  clip(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  compress(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  conj(...)
 |  
 |  conjugate(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  copy(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumprod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumsum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  diagonal(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dump(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dumps(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  fill(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  flatten(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  getfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  item(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  itemset(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  max(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  mean(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  min(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  newbyteorder(...)
 |      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.
 |      
 |      The `new_order` code can be any from the following:
 |      
 |      * 'S' - swap dtype from current to opposite endian
 |      * {'<', 'L'} - little endian
 |      * {'>', 'B'} - big endian
 |      * {'=', 'N'} - native order
 |      * {'|', 'I'} - ignore (no change to byte order)
 |      
 |      Parameters
 |      ----------
 |      new_order : str, optional
 |          Byte order to force; a value from the byte order specifications
 |          above.  The default value ('S') results in swapping the current
 |          byte order. The code does a case-insensitive check on the first
 |          letter of `new_order` for the alternatives above.  For example,
 |          any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 |      
 |      
 |      Returns
 |      -------
 |      new_dtype : dtype
 |          New `dtype` object with the given change to the byte order.
 |  
 |  nonzero(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  prod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ptp(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  put(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ravel(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  repeat(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  reshape(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  resize(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  round(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  searchsorted(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setflags(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  squeeze(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  std(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  swapaxes(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  take(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tobytes(...)
 |  
 |  tofile(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tolist(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tostring(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  trace(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  transpose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  var(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  view(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from generic:
 |  
 |  T
 |      transpose
 |  
 |  __array_interface__
 |      Array protocol: Python side
 |  
 |  __array_priority__
 |      Array priority.
 |  
 |  __array_struct__
 |      Array protocol: struct
 |  
 |  base
 |      base object
 |  
 |  data
 |      pointer to start of data
 |  
 |  dtype
 |      get array data-descriptor
 |  
 |  flags
 |      integer value of flags
 |  
 |  flat
 |      a 1-d view of scalar
 |  
 |  imag
 |      imaginary part of scalar
 |  
 |  itemsize
 |      length of one element in bytes
 |  
 |  nbytes
 |      length of item in bytes
 |  
 |  ndim
 |      number of array dimensions
 |  
 |  real
 |      real part of scalar
 |  
 |  shape
 |      tuple of array dimensions
 |  
 |  size
 |      number of elements in the gentype
 |  
 |  strides
 |      tuple of bytes steps in each dimension
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg.matfuncs.single,linalg.matfuncs,float32,"Python Library Documentation: class float32 in module numpy

class float32(floating)
 |  32-bit floating-point number. Character code 'f'. C float compatible.
 |  
 |  Method resolution order:
 |      float32
 |      floating
 |      inexact
 |      number
 |      generic
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from generic:
 |  
 |  __array__(...)
 |      sc.__array__(|type) return 0-dim array
 |  
 |  __array_wrap__(...)
 |      sc.__array_wrap__(obj) return scalar from array
 |  
 |  __copy__(...)
 |  
 |  __deepcopy__(...)
 |  
 |  __format__(...)
 |      NumPy array scalar formatter
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __round__(...)
 |  
 |  __setstate__(...)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  all(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  any(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmax(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argmin(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  argsort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  astype(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  byteswap(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  choose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  clip(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  compress(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  conj(...)
 |  
 |  conjugate(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  copy(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumprod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  cumsum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  diagonal(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dump(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  dumps(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  fill(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  flatten(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  getfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  item(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  itemset(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  max(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  mean(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  min(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  newbyteorder(...)
 |      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.
 |      
 |      The `new_order` code can be any from the following:
 |      
 |      * 'S' - swap dtype from current to opposite endian
 |      * {'<', 'L'} - little endian
 |      * {'>', 'B'} - big endian
 |      * {'=', 'N'} - native order
 |      * {'|', 'I'} - ignore (no change to byte order)
 |      
 |      Parameters
 |      ----------
 |      new_order : str, optional
 |          Byte order to force; a value from the byte order specifications
 |          above.  The default value ('S') results in swapping the current
 |          byte order. The code does a case-insensitive check on the first
 |          letter of `new_order` for the alternatives above.  For example,
 |          any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 |      
 |      
 |      Returns
 |      -------
 |      new_dtype : dtype
 |          New `dtype` object with the given change to the byte order.
 |  
 |  nonzero(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  prod(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ptp(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  put(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ravel(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  repeat(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  reshape(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  resize(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  round(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  searchsorted(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setfield(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  setflags(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class so as to
 |      provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sort(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  squeeze(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  std(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  sum(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  swapaxes(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  take(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tobytes(...)
 |  
 |  tofile(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tolist(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  tostring(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  trace(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  transpose(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  var(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  view(...)
 |      Not implemented (virtual attribute)
 |      
 |      Class generic exists solely to derive numpy scalars from, and possesses,
 |      albeit unimplemented, all the attributes of the ndarray class
 |      so as to provide a uniform API.
 |      
 |      See Also
 |      --------
 |      The corresponding attribute of the derived class of interest.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from generic:
 |  
 |  T
 |      transpose
 |  
 |  __array_interface__
 |      Array protocol: Python side
 |  
 |  __array_priority__
 |      Array priority.
 |  
 |  __array_struct__
 |      Array protocol: struct
 |  
 |  base
 |      base object
 |  
 |  data
 |      pointer to start of data
 |  
 |  dtype
 |      get array data-descriptor
 |  
 |  flags
 |      integer value of flags
 |  
 |  flat
 |      a 1-d view of scalar
 |  
 |  imag
 |      imaginary part of scalar
 |  
 |  itemsize
 |      length of one element in bytes
 |  
 |  nbytes
 |      length of item in bytes
 |  
 |  ndim
 |      number of array dimensions
 |  
 |  real
 |      real part of scalar
 |  
 |  shape
 |      tuple of array dimensions
 |  
 |  size
 |      number of elements in the gentype
 |  
 |  strides
 |      tuple of bytes steps in each dimension
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg.matfuncs.sinhm,linalg.matfuncs,sinhm,"Python Library Documentation: function sinhm in module scipy.linalg.matfuncs

sinhm(A)
    Compute the hyperbolic matrix sine.
    
    This routine uses expm to compute the matrix exponentials.
    
    Parameters
    ----------
    A : (N, N) array_like
        Input array.
    
    Returns
    -------
    sinhm : (N, N) ndarray
        Hyperbolic matrix sine of `A`
    
    Examples
    --------
    >>> from scipy.linalg import tanhm, sinhm, coshm
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> s = sinhm(a)
    >>> s
    array([[ 10.57300653,  39.28826594],
           [ 13.09608865,  49.86127247]])
    
    Verify tanhm(a) = sinhm(a).dot(inv(coshm(a)))
    
    >>> t = tanhm(a)
    >>> c = coshm(a)
    >>> t - s.dot(np.linalg.inv(c))
    array([[  2.72004641e-15,   4.55191440e-15],
           [  0.00000000e+00,  -5.55111512e-16]])
",function,"('(A)',)",scipy,1.1.0,scipy.linalg.matfuncs.sinhm,linalg.matfuncs,sinhm,"Python Library Documentation: function sinhm in module scipy.linalg.matfuncs

sinhm(A)
    Compute the hyperbolic matrix sine.
    
    This routine uses expm to compute the matrix exponentials.
    
    Parameters
    ----------
    A : (N, N) array_like
        Input array.
    
    Returns
    -------
    sinhm : (N, N) ndarray
        Hyperbolic matrix sine of `A`
    
    Examples
    --------
    >>> from scipy.linalg import tanhm, sinhm, coshm
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> s = sinhm(a)
    >>> s
    array([[ 10.57300653,  39.28826594],
           [ 13.09608865,  49.86127247]])
    
    Verify tanhm(a) = sinhm(a).dot(inv(coshm(a)))
    
    >>> t = tanhm(a)
    >>> c = coshm(a)
    >>> t - s.dot(np.linalg.inv(c))
    array([[  2.72004641e-15,   4.55191440e-15],
           [  0.00000000e+00,  -5.55111512e-16]])
",function,"('A',)","(nan,)","(nan,)","('arg_info',)","('(A)',)"
scipy,1.1.0,scipy.linalg.matfuncs.sinm,linalg.matfuncs,sinm,"Python Library Documentation: function sinm in module scipy.linalg.matfuncs

sinm(A)
    Compute the matrix sine.
    
    This routine uses expm to compute the matrix exponentials.
    
    Parameters
    ----------
    A : (N, N) array_like
        Input array.
    
    Returns
    -------
    sinm : (N, N) ndarray
        Matrix sine of `A`
    
    Examples
    --------
    >>> from scipy.linalg import expm, sinm, cosm
    
    Euler's identity (exp(i*theta) = cos(theta) + i*sin(theta))
    applied to a matrix:
    
    >>> a = np.array([[1.0, 2.0], [-1.0, 3.0]])
    >>> expm(1j*a)
    array([[ 0.42645930+1.89217551j, -2.13721484-0.97811252j],
           [ 1.06860742+0.48905626j, -1.71075555+0.91406299j]])
    >>> cosm(a) + 1j*sinm(a)
    array([[ 0.42645930+1.89217551j, -2.13721484-0.97811252j],
           [ 1.06860742+0.48905626j, -1.71075555+0.91406299j]])
",function,"('(A)',)",scipy,1.1.0,scipy.linalg.matfuncs.sinm,linalg.matfuncs,sinm,"Python Library Documentation: function sinm in module scipy.linalg.matfuncs

sinm(A)
    Compute the matrix sine.
    
    This routine uses expm to compute the matrix exponentials.
    
    Parameters
    ----------
    A : (N, N) array_like
        Input array.
    
    Returns
    -------
    sinm : (N, N) ndarray
        Matrix sine of `A`
    
    Examples
    --------
    >>> from scipy.linalg import expm, sinm, cosm
    
    Euler's identity (exp(i*theta) = cos(theta) + i*sin(theta))
    applied to a matrix:
    
    >>> a = np.array([[1.0, 2.0], [-1.0, 3.0]])
    >>> expm(1j*a)
    array([[ 0.42645930+1.89217551j, -2.13721484-0.97811252j],
           [ 1.06860742+0.48905626j, -1.71075555+0.91406299j]])
    >>> cosm(a) + 1j*sinm(a)
    array([[ 0.42645930+1.89217551j, -2.13721484-0.97811252j],
           [ 1.06860742+0.48905626j, -1.71075555+0.91406299j]])
",function,"('A',)","(nan,)","(nan,)","('arg_info',)","('(A)',)"
scipy,1.1.0,scipy.linalg.matfuncs.solve,linalg.matfuncs,solve,"Python Library Documentation: function solve in module scipy.linalg.basic

solve(a, b, sym_pos=False, lower=False, overwrite_a=False, overwrite_b=False, debug=None, check_finite=True, assume_a='gen', transposed=False)
    Solves the linear equation set ``a * x = b`` for the unknown ``x``
    for square ``a`` matrix.
    
    If the data matrix is known to be a particular type then supplying the
    corresponding string to ``assume_a`` key chooses the dedicated solver.
    The available options are
    
    ===================  ========
     generic matrix       'gen'
     symmetric            'sym'
     hermitian            'her'
     positive definite    'pos'
    ===================  ========
    
    If omitted, ``'gen'`` is the default structure.
    
    The datatype of the arrays define which solver is called regardless
    of the values. In other words, even when the complex array entries have
    precisely zero imaginary parts, the complex solver will be called based
    on the data type of the array.
    
    Parameters
    ----------
    a : (N, N) array_like
        Square input data
    b : (N, NRHS) array_like
        Input data for the right hand side.
    sym_pos : bool, optional
        Assume `a` is symmetric and positive definite. This key is deprecated
        and assume_a = 'pos' keyword is recommended instead. The functionality
        is the same. It will be removed in the future.
    lower : bool, optional
        If True, only the data contained in the lower triangle of `a`. Default
        is to use upper triangle. (ignored for ``'gen'``)
    overwrite_a : bool, optional
        Allow overwriting data in `a` (may enhance performance).
        Default is False.
    overwrite_b : bool, optional
        Allow overwriting data in `b` (may enhance performance).
        Default is False.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    assume_a : str, optional
        Valid entries are explained above.
    transposed: bool, optional
        If True, ``a^T x = b`` for real matrices, raises `NotImplementedError`
        for complex matrices (only for True).
    
    Returns
    -------
    x : (N, NRHS) ndarray
        The solution array.
    
    Raises
    ------
    ValueError
        If size mismatches detected or input a is not square.
    LinAlgError
        If the matrix is singular.
    LinAlgWarning
        If an ill-conditioned input a is detected.
    NotImplementedError
        If transposed is True and input a is a complex matrix.
    
    Examples
    --------
    Given `a` and `b`, solve for `x`:
    
    >>> a = np.array([[3, 2, 0], [1, -1, 0], [0, 5, 1]])
    >>> b = np.array([2, 4, -1])
    >>> from scipy import linalg
    >>> x = linalg.solve(a, b)
    >>> x
    array([ 2., -2.,  9.])
    >>> np.dot(a, x) == b
    array([ True,  True,  True], dtype=bool)
    
    Notes
    -----
    If the input b matrix is a 1D array with N elements, when supplied
    together with an NxN input a, it is assumed as a valid column vector
    despite the apparent size mismatch. This is compatible with the
    numpy.dot() behavior and the returned result is still 1D array.
    
    The generic, symmetric, hermitian and positive definite solutions are
    obtained via calling ?GESV, ?SYSV, ?HESV, and ?POSV routines of
    LAPACK respectively.
",function,"(""(a, b, sym_pos=False, lower=False, overwrite_a=False, overwrite_b=False, debug=None, check_finite=True, assume_a='gen', transposed=False)"",)",scipy,1.1.0,scipy.linalg.matfuncs.solve,linalg.matfuncs,solve,"Python Library Documentation: function solve in module scipy.linalg.basic

solve(a, b, sym_pos=False, lower=False, overwrite_a=False, overwrite_b=False, debug=None, check_finite=True, assume_a='gen', transposed=False)
    Solves the linear equation set ``a * x = b`` for the unknown ``x``
    for square ``a`` matrix.
    
    If the data matrix is known to be a particular type then supplying the
    corresponding string to ``assume_a`` key chooses the dedicated solver.
    The available options are
    
    ===================  ========
     generic matrix       'gen'
     symmetric            'sym'
     hermitian            'her'
     positive definite    'pos'
    ===================  ========
    
    If omitted, ``'gen'`` is the default structure.
    
    The datatype of the arrays define which solver is called regardless
    of the values. In other words, even when the complex array entries have
    precisely zero imaginary parts, the complex solver will be called based
    on the data type of the array.
    
    Parameters
    ----------
    a : (N, N) array_like
        Square input data
    b : (N, NRHS) array_like
        Input data for the right hand side.
    sym_pos : bool, optional
        Assume `a` is symmetric and positive definite. This key is deprecated
        and assume_a = 'pos' keyword is recommended instead. The functionality
        is the same. It will be removed in the future.
    lower : bool, optional
        If True, only the data contained in the lower triangle of `a`. Default
        is to use upper triangle. (ignored for ``'gen'``)
    overwrite_a : bool, optional
        Allow overwriting data in `a` (may enhance performance).
        Default is False.
    overwrite_b : bool, optional
        Allow overwriting data in `b` (may enhance performance).
        Default is False.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    assume_a : str, optional
        Valid entries are explained above.
    transposed: bool, optional
        If True, ``a^T x = b`` for real matrices, raises `NotImplementedError`
        for complex matrices (only for True).
    
    Returns
    -------
    x : (N, NRHS) ndarray
        The solution array.
    
    Raises
    ------
    ValueError
        If size mismatches detected or input a is not square.
    LinAlgError
        If the matrix is singular.
    LinAlgWarning
        If an ill-conditioned input a is detected.
    NotImplementedError
        If transposed is True and input a is a complex matrix.
    
    Examples
    --------
    Given `a` and `b`, solve for `x`:
    
    >>> a = np.array([[3, 2, 0], [1, -1, 0], [0, 5, 1]])
    >>> b = np.array([2, 4, -1])
    >>> from scipy import linalg
    >>> x = linalg.solve(a, b)
    >>> x
    array([ 2., -2.,  9.])
    >>> np.dot(a, x) == b
    array([ True,  True,  True], dtype=bool)
    
    Notes
    -----
    If the input b matrix is a 1D array with N elements, when supplied
    together with an NxN input a, it is assumed as a valid column vector
    despite the apparent size mismatch. This is compatible with the
    numpy.dot() behavior and the returned result is still 1D array.
    
    The generic, symmetric, hermitian and positive definite solutions are
    obtained via calling ?GESV, ?SYSV, ?HESV, and ?POSV routines of
    LAPACK respectively.
",function,"('a', 'b', 'sym_pos', 'lower', 'overwrite_a', 'overwrite_b', 'debug', 'check_finite', 'assume_a', 'transposed')","(nan, nan, False, False, False, False, None, True, 'gen', False)","(nan, nan, 'bool', 'bool', 'bool', 'bool', 'NoneType', 'bool', 'str', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a, b, sym_pos=False, lower=False, overwrite_a=False, overwrite_b=False, debug=None, check_finite=True, assume_a='gen', transposed=False)"",)"
scipy,1.1.0,scipy.linalg.matfuncs.sqrtm,linalg.matfuncs,sqrtm,"Python Library Documentation: function sqrtm in module scipy.linalg._matfuncs_sqrtm

sqrtm(A, disp=True, blocksize=64)
    Matrix square root.
    
    Parameters
    ----------
    A : (N, N) array_like
        Matrix whose square root to evaluate
    disp : bool, optional
        Print warning if error in the result is estimated large
        instead of returning estimated error. (Default: True)
    blocksize : integer, optional
        If the blocksize is not degenerate with respect to the
        size of the input array, then use a blocked algorithm. (Default: 64)
    
    Returns
    -------
    sqrtm : (N, N) ndarray
        Value of the sqrt function at `A`
    
    errest : float
        (if disp == False)
    
        Frobenius norm of the estimated error, ||err||_F / ||A||_F
    
    References
    ----------
    .. [1] Edvin Deadman, Nicholas J. Higham, Rui Ralha (2013)
           ""Blocked Schur Algorithms for Computing the Matrix Square Root,
           Lecture Notes in Computer Science, 7782. pp. 171-182.
    
    Examples
    --------
    >>> from scipy.linalg import sqrtm
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> r = sqrtm(a)
    >>> r
    array([[ 0.75592895,  1.13389342],
           [ 0.37796447,  1.88982237]])
    >>> r.dot(r)
    array([[ 1.,  3.],
           [ 1.,  4.]])
",function,"('(A, disp=True, blocksize=64)',)",scipy,1.1.0,scipy.linalg.matfuncs.sqrtm,linalg.matfuncs,sqrtm,"Python Library Documentation: function sqrtm in module scipy.linalg._matfuncs_sqrtm

sqrtm(A, disp=True, blocksize=64)
    Matrix square root.
    
    Parameters
    ----------
    A : (N, N) array_like
        Matrix whose square root to evaluate
    disp : bool, optional
        Print warning if error in the result is estimated large
        instead of returning estimated error. (Default: True)
    blocksize : integer, optional
        If the blocksize is not degenerate with respect to the
        size of the input array, then use a blocked algorithm. (Default: 64)
    
    Returns
    -------
    sqrtm : (N, N) ndarray
        Value of the sqrt function at `A`
    
    errest : float
        (if disp == False)
    
        Frobenius norm of the estimated error, ||err||_F / ||A||_F
    
    References
    ----------
    .. [1] Edvin Deadman, Nicholas J. Higham, Rui Ralha (2013)
           ""Blocked Schur Algorithms for Computing the Matrix Square Root,
           Lecture Notes in Computer Science, 7782. pp. 171-182.
    
    Examples
    --------
    >>> from scipy.linalg import sqrtm
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> r = sqrtm(a)
    >>> r
    array([[ 0.75592895,  1.13389342],
           [ 0.37796447,  1.88982237]])
    >>> r.dot(r)
    array([[ 1.,  3.],
           [ 1.,  4.]])
",function,"('A', 'disp', 'blocksize')","(nan, True, 64)","(nan, 'bool', 'int')","('arg_info', 'arg_info', 'arg_info')","('(A, disp=True, blocksize=64)',)"
scipy,1.1.0,scipy.linalg.matfuncs.svd,linalg.matfuncs,svd,"Python Library Documentation: function svd in module scipy.linalg.decomp_svd

svd(a, full_matrices=True, compute_uv=True, overwrite_a=False, check_finite=True, lapack_driver='gesdd')
    Singular Value Decomposition.
    
    Factorizes the matrix `a` into two unitary matrices ``U`` and ``Vh``, and
    a 1-D array ``s`` of singular values (real, non-negative) such that
    ``a == U @ S @ Vh``, where ``S`` is a suitably shaped matrix of zeros with
    main diagonal ``s``.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to decompose.
    full_matrices : bool, optional
        If True (default), `U` and `Vh` are of shape ``(M, M)``, ``(N, N)``.
        If False, the shapes are ``(M, K)`` and ``(K, N)``, where
        ``K = min(M, N)``.
    compute_uv : bool, optional
        Whether to compute also ``U`` and ``Vh`` in addition to ``s``.
        Default is True.
    overwrite_a : bool, optional
        Whether to overwrite `a`; may improve performance.
        Default is False.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    lapack_driver : {'gesdd', 'gesvd'}, optional
        Whether to use the more efficient divide-and-conquer approach
        (``'gesdd'``) or general rectangular approach (``'gesvd'``)
        to compute the SVD. MATLAB and Octave use the ``'gesvd'`` approach.
        Default is ``'gesdd'``.
    
        .. versionadded:: 0.18
    
    Returns
    -------
    U : ndarray
        Unitary matrix having left singular vectors as columns.
        Of shape ``(M, M)`` or ``(M, K)``, depending on `full_matrices`.
    s : ndarray
        The singular values, sorted in non-increasing order.
        Of shape (K,), with ``K = min(M, N)``.
    Vh : ndarray
        Unitary matrix having right singular vectors as rows.
        Of shape ``(N, N)`` or ``(K, N)`` depending on `full_matrices`.
    
    For ``compute_uv=False``, only ``s`` is returned.
    
    Raises
    ------
    LinAlgError
        If SVD computation does not converge.
    
    See also
    --------
    svdvals : Compute singular values of a matrix.
    diagsvd : Construct the Sigma matrix, given the vector s.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> m, n = 9, 6
    >>> a = np.random.randn(m, n) + 1.j*np.random.randn(m, n)
    >>> U, s, Vh = linalg.svd(a)
    >>> U.shape,  s.shape, Vh.shape
    ((9, 9), (6,), (6, 6))
    
    Reconstruct the original matrix from the decomposition:
    
    >>> sigma = np.zeros((m, n))
    >>> for i in range(min(m, n)):
    ...     sigma[i, i] = s[i]
    >>> a1 = np.dot(U, np.dot(sigma, Vh))
    >>> np.allclose(a, a1)
    True
    
    Alternatively, use ``full_matrices=False`` (notice that the shape of
    ``U`` is then ``(m, n)`` instead of ``(m, m)``):
    
    >>> U, s, Vh = linalg.svd(a, full_matrices=False)
    >>> U.shape, s.shape, Vh.shape
    ((9, 6), (6,), (6, 6))
    >>> S = np.diag(s)
    >>> np.allclose(a, np.dot(U, np.dot(S, Vh)))
    True
    
    >>> s2 = linalg.svd(a, compute_uv=False)
    >>> np.allclose(s, s2)
    True
",function,"(""(a, full_matrices=True, compute_uv=True, overwrite_a=False, check_finite=True, lapack_driver='gesdd')"",)",scipy,1.1.0,scipy.linalg.matfuncs.svd,linalg.matfuncs,svd,"Python Library Documentation: function svd in module scipy.linalg.decomp_svd

svd(a, full_matrices=True, compute_uv=True, overwrite_a=False, check_finite=True, lapack_driver='gesdd')
    Singular Value Decomposition.
    
    Factorizes the matrix `a` into two unitary matrices ``U`` and ``Vh``, and
    a 1-D array ``s`` of singular values (real, non-negative) such that
    ``a == U @ S @ Vh``, where ``S`` is a suitably shaped matrix of zeros with
    main diagonal ``s``.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to decompose.
    full_matrices : bool, optional
        If True (default), `U` and `Vh` are of shape ``(M, M)``, ``(N, N)``.
        If False, the shapes are ``(M, K)`` and ``(K, N)``, where
        ``K = min(M, N)``.
    compute_uv : bool, optional
        Whether to compute also ``U`` and ``Vh`` in addition to ``s``.
        Default is True.
    overwrite_a : bool, optional
        Whether to overwrite `a`; may improve performance.
        Default is False.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    lapack_driver : {'gesdd', 'gesvd'}, optional
        Whether to use the more efficient divide-and-conquer approach
        (``'gesdd'``) or general rectangular approach (``'gesvd'``)
        to compute the SVD. MATLAB and Octave use the ``'gesvd'`` approach.
        Default is ``'gesdd'``.
    
        .. versionadded:: 0.18
    
    Returns
    -------
    U : ndarray
        Unitary matrix having left singular vectors as columns.
        Of shape ``(M, M)`` or ``(M, K)``, depending on `full_matrices`.
    s : ndarray
        The singular values, sorted in non-increasing order.
        Of shape (K,), with ``K = min(M, N)``.
    Vh : ndarray
        Unitary matrix having right singular vectors as rows.
        Of shape ``(N, N)`` or ``(K, N)`` depending on `full_matrices`.
    
    For ``compute_uv=False``, only ``s`` is returned.
    
    Raises
    ------
    LinAlgError
        If SVD computation does not converge.
    
    See also
    --------
    svdvals : Compute singular values of a matrix.
    diagsvd : Construct the Sigma matrix, given the vector s.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> m, n = 9, 6
    >>> a = np.random.randn(m, n) + 1.j*np.random.randn(m, n)
    >>> U, s, Vh = linalg.svd(a)
    >>> U.shape,  s.shape, Vh.shape
    ((9, 9), (6,), (6, 6))
    
    Reconstruct the original matrix from the decomposition:
    
    >>> sigma = np.zeros((m, n))
    >>> for i in range(min(m, n)):
    ...     sigma[i, i] = s[i]
    >>> a1 = np.dot(U, np.dot(sigma, Vh))
    >>> np.allclose(a, a1)
    True
    
    Alternatively, use ``full_matrices=False`` (notice that the shape of
    ``U`` is then ``(m, n)`` instead of ``(m, m)``):
    
    >>> U, s, Vh = linalg.svd(a, full_matrices=False)
    >>> U.shape, s.shape, Vh.shape
    ((9, 6), (6,), (6, 6))
    >>> S = np.diag(s)
    >>> np.allclose(a, np.dot(U, np.dot(S, Vh)))
    True
    
    >>> s2 = linalg.svd(a, compute_uv=False)
    >>> np.allclose(s, s2)
    True
",function,"('a', 'full_matrices', 'compute_uv', 'overwrite_a', 'check_finite', 'lapack_driver')","(nan, True, True, False, True, 'gesdd')","(nan, 'bool', 'bool', 'bool', 'bool', 'str')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a, full_matrices=True, compute_uv=True, overwrite_a=False, check_finite=True, lapack_driver='gesdd')"",)"
scipy,1.1.0,scipy.linalg.matfuncs.tanhm,linalg.matfuncs,tanhm,"Python Library Documentation: function tanhm in module scipy.linalg.matfuncs

tanhm(A)
    Compute the hyperbolic matrix tangent.
    
    This routine uses expm to compute the matrix exponentials.
    
    Parameters
    ----------
    A : (N, N) array_like
        Input array
    
    Returns
    -------
    tanhm : (N, N) ndarray
        Hyperbolic matrix tangent of `A`
    
    Examples
    --------
    >>> from scipy.linalg import tanhm, sinhm, coshm
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> t = tanhm(a)
    >>> t
    array([[ 0.3428582 ,  0.51987926],
           [ 0.17329309,  0.86273746]])
    
    Verify tanhm(a) = sinhm(a).dot(inv(coshm(a)))
    
    >>> s = sinhm(a)
    >>> c = coshm(a)
    >>> t - s.dot(np.linalg.inv(c))
    array([[  2.72004641e-15,   4.55191440e-15],
           [  0.00000000e+00,  -5.55111512e-16]])
",function,"('(A)',)",scipy,1.1.0,scipy.linalg.matfuncs.tanhm,linalg.matfuncs,tanhm,"Python Library Documentation: function tanhm in module scipy.linalg.matfuncs

tanhm(A)
    Compute the hyperbolic matrix tangent.
    
    This routine uses expm to compute the matrix exponentials.
    
    Parameters
    ----------
    A : (N, N) array_like
        Input array
    
    Returns
    -------
    tanhm : (N, N) ndarray
        Hyperbolic matrix tangent of `A`
    
    Examples
    --------
    >>> from scipy.linalg import tanhm, sinhm, coshm
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> t = tanhm(a)
    >>> t
    array([[ 0.3428582 ,  0.51987926],
           [ 0.17329309,  0.86273746]])
    
    Verify tanhm(a) = sinhm(a).dot(inv(coshm(a)))
    
    >>> s = sinhm(a)
    >>> c = coshm(a)
    >>> t - s.dot(np.linalg.inv(c))
    array([[  2.72004641e-15,   4.55191440e-15],
           [  0.00000000e+00,  -5.55111512e-16]])
",function,"('A',)","(nan,)","(nan,)","('arg_info',)","('(A)',)"
scipy,1.1.0,scipy.linalg.matfuncs.tanm,linalg.matfuncs,tanm,"Python Library Documentation: function tanm in module scipy.linalg.matfuncs

tanm(A)
    Compute the matrix tangent.
    
    This routine uses expm to compute the matrix exponentials.
    
    Parameters
    ----------
    A : (N, N) array_like
        Input array.
    
    Returns
    -------
    tanm : (N, N) ndarray
        Matrix tangent of `A`
    
    Examples
    --------
    >>> from scipy.linalg import tanm, sinm, cosm
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> t = tanm(a)
    >>> t
    array([[ -2.00876993,  -8.41880636],
           [ -2.80626879, -10.42757629]])
    
    Verify tanm(a) = sinm(a).dot(inv(cosm(a)))
    
    >>> s = sinm(a)
    >>> c = cosm(a)
    >>> s.dot(np.linalg.inv(c))
    array([[ -2.00876993,  -8.41880636],
           [ -2.80626879, -10.42757629]])
",function,"('(A)',)",scipy,1.1.0,scipy.linalg.matfuncs.tanm,linalg.matfuncs,tanm,"Python Library Documentation: function tanm in module scipy.linalg.matfuncs

tanm(A)
    Compute the matrix tangent.
    
    This routine uses expm to compute the matrix exponentials.
    
    Parameters
    ----------
    A : (N, N) array_like
        Input array.
    
    Returns
    -------
    tanm : (N, N) ndarray
        Matrix tangent of `A`
    
    Examples
    --------
    >>> from scipy.linalg import tanm, sinm, cosm
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> t = tanm(a)
    >>> t
    array([[ -2.00876993,  -8.41880636],
           [ -2.80626879, -10.42757629]])
    
    Verify tanm(a) = sinm(a).dot(inv(cosm(a)))
    
    >>> s = sinm(a)
    >>> c = cosm(a)
    >>> s.dot(np.linalg.inv(c))
    array([[ -2.00876993,  -8.41880636],
           [ -2.80626879, -10.42757629]])
",function,"('A',)","(nan,)","(nan,)","('arg_info',)","('(A)',)"
scipy,1.1.0,scipy.linalg.matfuncs.transpose,linalg.matfuncs,transpose,"Python Library Documentation: function transpose in module numpy.core.fromnumeric

transpose(a, axes=None)
    Permute the dimensions of an array.
    
    Parameters
    ----------
    a : array_like
        Input array.
    axes : list of ints, optional
        By default, reverse the dimensions, otherwise permute the axes
        according to the values given.
    
    Returns
    -------
    p : ndarray
        `a` with its axes permuted.  A view is returned whenever
        possible.
    
    See Also
    --------
    moveaxis
    argsort
    
    Notes
    -----
    Use `transpose(a, argsort(axes))` to invert the transposition of tensors
    when using the `axes` keyword argument.
    
    Transposing a 1-D array returns an unchanged view of the original array.
    
    Examples
    --------
    >>> x = np.arange(4).reshape((2,2))
    >>> x
    array([[0, 1],
           [2, 3]])
    
    >>> np.transpose(x)
    array([[0, 2],
           [1, 3]])
    
    >>> x = np.ones((1, 2, 3))
    >>> np.transpose(x, (1, 0, 2)).shape
    (2, 1, 3)
",function,"('(a, axes=None)',)",scipy,1.1.0,scipy.linalg.matfuncs.transpose,linalg.matfuncs,transpose,"Python Library Documentation: function transpose in module numpy.core.fromnumeric

transpose(a, axes=None)
    Permute the dimensions of an array.
    
    Parameters
    ----------
    a : array_like
        Input array.
    axes : list of ints, optional
        By default, reverse the dimensions, otherwise permute the axes
        according to the values given.
    
    Returns
    -------
    p : ndarray
        `a` with its axes permuted.  A view is returned whenever
        possible.
    
    See Also
    --------
    moveaxis
    argsort
    
    Notes
    -----
    Use `transpose(a, argsort(axes))` to invert the transposition of tensors
    when using the `axes` keyword argument.
    
    Transposing a 1-D array returns an unchanged view of the original array.
    
    Examples
    --------
    >>> x = np.arange(4).reshape((2,2))
    >>> x
    array([[0, 1],
           [2, 3]])
    
    >>> np.transpose(x)
    array([[0, 2],
           [1, 3]])
    
    >>> x = np.ones((1, 2, 3))
    >>> np.transpose(x, (1, 0, 2)).shape
    (2, 1, 3)
",function,"('a', 'axes')","(nan, None)","(nan, 'NoneType')","('arg_info', 'arg_info')","('(a, axes=None)',)"
scipy,1.1.0,scipy.linalg.matfuncs.triu,linalg.matfuncs,triu,"Python Library Documentation: function triu in module scipy.linalg.special_matrices

triu(m, k=0)
    Make a copy of a matrix with elements below the k-th diagonal zeroed.
    
    Parameters
    ----------
    m : array_like
        Matrix whose elements to return
    k : int, optional
        Diagonal below which to zero elements.
        `k` == 0 is the main diagonal, `k` < 0 subdiagonal and
        `k` > 0 superdiagonal.
    
    Returns
    -------
    triu : ndarray
        Return matrix with zeroed elements below the k-th diagonal and has
        same shape and type as `m`.
    
    Examples
    --------
    >>> from scipy.linalg import triu
    >>> triu([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
    array([[ 1,  2,  3],
           [ 4,  5,  6],
           [ 0,  8,  9],
           [ 0,  0, 12]])
",function,"('(m, k=0)',)",scipy,1.1.0,scipy.linalg.matfuncs.triu,linalg.matfuncs,triu,"Python Library Documentation: function triu in module scipy.linalg.special_matrices

triu(m, k=0)
    Make a copy of a matrix with elements below the k-th diagonal zeroed.
    
    Parameters
    ----------
    m : array_like
        Matrix whose elements to return
    k : int, optional
        Diagonal below which to zero elements.
        `k` == 0 is the main diagonal, `k` < 0 subdiagonal and
        `k` > 0 superdiagonal.
    
    Returns
    -------
    triu : ndarray
        Return matrix with zeroed elements below the k-th diagonal and has
        same shape and type as `m`.
    
    Examples
    --------
    >>> from scipy.linalg import triu
    >>> triu([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
    array([[ 1,  2,  3],
           [ 4,  5,  6],
           [ 0,  8,  9],
           [ 0,  0, 12]])
",function,"('m', 'k')","(nan, 0)","(nan, 'int')","('arg_info', 'arg_info')","('(m, k=0)',)"
scipy,1.1.0,scipy.linalg.matrix_balance,linalg,matrix_balance,"Python Library Documentation: function matrix_balance in module scipy.linalg.basic

matrix_balance(A, permute=True, scale=True, separate=False, overwrite_a=False)
    Compute a diagonal similarity transformation for row/column balancing.
    
    The balancing tries to equalize the row and column 1-norms by applying
    a similarity transformation such that the magnitude variation of the
    matrix entries is reflected to the scaling matrices.
    
    Moreover, if enabled, the matrix is first permuted to isolate the upper
    triangular parts of the matrix and, again if scaling is also enabled,
    only the remaining subblocks are subjected to scaling.
    
    The balanced matrix satisfies the following equality
    
    .. math::
    
                        B = T^{-1} A T
    
    The scaling coefficients are approximated to the nearest power of 2
    to avoid round-off errors.
    
    Parameters
    ----------
    A : (n, n) array_like
        Square data matrix for the balancing.
    permute : bool, optional
        The selector to define whether permutation of A is also performed
        prior to scaling.
    scale : bool, optional
        The selector to turn on and off the scaling. If False, the matrix
        will not be scaled.
    separate : bool, optional
        This switches from returning a full matrix of the transformation
        to a tuple of two separate 1D permutation and scaling arrays.
    overwrite_a : bool, optional
        This is passed to xGEBAL directly. Essentially, overwrites the result
        to the data. It might increase the space efficiency. See LAPACK manual
        for details. This is False by default.
    
    Returns
    -------
    B : (n, n) ndarray
        Balanced matrix
    T : (n, n) ndarray
        A possibly permuted diagonal matrix whose nonzero entries are
        integer powers of 2 to avoid numerical truncation errors.
    scale, perm : (n,) ndarray
        If ``separate`` keyword is set to True then instead of the array
        ``T`` above, the scaling and the permutation vectors are given
        separately as a tuple without allocating the full array ``T``.
    
    .. versionadded:: 0.19.0
    
    Notes
    -----
    
    This algorithm is particularly useful for eigenvalue and matrix
    decompositions and in many cases it is already called by various
    LAPACK routines.
    
    The algorithm is based on the well-known technique of [1]_ and has
    been modified to account for special cases. See [2]_ for details
    which have been implemented since LAPACK v3.5.0. Before this version
    there are corner cases where balancing can actually worsen the
    conditioning. See [3]_ for such examples.
    
    The code is a wrapper around LAPACK's xGEBAL routine family for matrix
    balancing.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> x = np.array([[1,2,0], [9,1,0.01], [1,2,10*np.pi]])
    
    >>> y, permscale = linalg.matrix_balance(x)
    >>> np.abs(x).sum(axis=0) / np.abs(x).sum(axis=1)
    array([ 3.66666667,  0.4995005 ,  0.91312162])
    
    >>> np.abs(y).sum(axis=0) / np.abs(y).sum(axis=1)
    array([ 1.2       ,  1.27041742,  0.92658316])  # may vary
    
    >>> permscale  # only powers of 2 (0.5 == 2^(-1))
    array([[  0.5,   0. ,  0. ],  # may vary
           [  0. ,   1. ,  0. ],
           [  0. ,   0. ,  1. ]])
    
    References
    ----------
    .. [1] : B.N. Parlett and C. Reinsch, ""Balancing a Matrix for
       Calculation of Eigenvalues and Eigenvectors"", Numerische Mathematik,
       Vol.13(4), 1969, DOI:10.1007/BF02165404
    
    .. [2] : R. James, J. Langou, B.R. Lowery, ""On matrix balancing and
       eigenvector computation"", 2014, Available online:
       http://arxiv.org/abs/1401.5766
    
    .. [3] :  D.S. Watkins. A case where balancing is harmful.
       Electron. Trans. Numer. Anal, Vol.23, 2006.
",function,"('(A, permute=True, scale=True, separate=False, overwrite_a=False)',)",scipy,1.1.0,scipy.linalg.matrix_balance,linalg,matrix_balance,"Python Library Documentation: function matrix_balance in module scipy.linalg.basic

matrix_balance(A, permute=True, scale=True, separate=False, overwrite_a=False)
    Compute a diagonal similarity transformation for row/column balancing.
    
    The balancing tries to equalize the row and column 1-norms by applying
    a similarity transformation such that the magnitude variation of the
    matrix entries is reflected to the scaling matrices.
    
    Moreover, if enabled, the matrix is first permuted to isolate the upper
    triangular parts of the matrix and, again if scaling is also enabled,
    only the remaining subblocks are subjected to scaling.
    
    The balanced matrix satisfies the following equality
    
    .. math::
    
                        B = T^{-1} A T
    
    The scaling coefficients are approximated to the nearest power of 2
    to avoid round-off errors.
    
    Parameters
    ----------
    A : (n, n) array_like
        Square data matrix for the balancing.
    permute : bool, optional
        The selector to define whether permutation of A is also performed
        prior to scaling.
    scale : bool, optional
        The selector to turn on and off the scaling. If False, the matrix
        will not be scaled.
    separate : bool, optional
        This switches from returning a full matrix of the transformation
        to a tuple of two separate 1D permutation and scaling arrays.
    overwrite_a : bool, optional
        This is passed to xGEBAL directly. Essentially, overwrites the result
        to the data. It might increase the space efficiency. See LAPACK manual
        for details. This is False by default.
    
    Returns
    -------
    B : (n, n) ndarray
        Balanced matrix
    T : (n, n) ndarray
        A possibly permuted diagonal matrix whose nonzero entries are
        integer powers of 2 to avoid numerical truncation errors.
    scale, perm : (n,) ndarray
        If ``separate`` keyword is set to True then instead of the array
        ``T`` above, the scaling and the permutation vectors are given
        separately as a tuple without allocating the full array ``T``.
    
    .. versionadded:: 0.19.0
    
    Notes
    -----
    
    This algorithm is particularly useful for eigenvalue and matrix
    decompositions and in many cases it is already called by various
    LAPACK routines.
    
    The algorithm is based on the well-known technique of [1]_ and has
    been modified to account for special cases. See [2]_ for details
    which have been implemented since LAPACK v3.5.0. Before this version
    there are corner cases where balancing can actually worsen the
    conditioning. See [3]_ for such examples.
    
    The code is a wrapper around LAPACK's xGEBAL routine family for matrix
    balancing.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> x = np.array([[1,2,0], [9,1,0.01], [1,2,10*np.pi]])
    
    >>> y, permscale = linalg.matrix_balance(x)
    >>> np.abs(x).sum(axis=0) / np.abs(x).sum(axis=1)
    array([ 3.66666667,  0.4995005 ,  0.91312162])
    
    >>> np.abs(y).sum(axis=0) / np.abs(y).sum(axis=1)
    array([ 1.2       ,  1.27041742,  0.92658316])  # may vary
    
    >>> permscale  # only powers of 2 (0.5 == 2^(-1))
    array([[  0.5,   0. ,  0. ],  # may vary
           [  0. ,   1. ,  0. ],
           [  0. ,   0. ,  1. ]])
    
    References
    ----------
    .. [1] : B.N. Parlett and C. Reinsch, ""Balancing a Matrix for
       Calculation of Eigenvalues and Eigenvectors"", Numerische Mathematik,
       Vol.13(4), 1969, DOI:10.1007/BF02165404
    
    .. [2] : R. James, J. Langou, B.R. Lowery, ""On matrix balancing and
       eigenvector computation"", 2014, Available online:
       http://arxiv.org/abs/1401.5766
    
    .. [3] :  D.S. Watkins. A case where balancing is harmful.
       Electron. Trans. Numer. Anal, Vol.23, 2006.
",function,"('A', 'permute', 'scale', 'separate', 'overwrite_a')","(nan, True, True, False, False)","(nan, 'bool', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(A, permute=True, scale=True, separate=False, overwrite_a=False)',)"
scipy,1.1.0,scipy.linalg.misc.LinAlgError,linalg.misc,LinAlgError,"Python Library Documentation: class LinAlgError in module numpy.linalg.linalg

class LinAlgError(builtins.Exception)
 |  Generic Python-exception-derived object raised by linalg functions.
 |  
 |  General purpose exception class, derived from Python's exception.Exception
 |  class, programmatically raised in linalg functions when a Linear
 |  Algebra-related condition would prevent further correct execution of the
 |  function.
 |  
 |  Parameters
 |  ----------
 |  None
 |  
 |  Examples
 |  --------
 |  >>> from numpy import linalg as LA
 |  >>> LA.inv(np.zeros((2,2)))
 |  Traceback (most recent call last):
 |    File ""<stdin>"", line 1, in <module>
 |    File ""...linalg.py"", line 350,
 |      in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
 |    File ""...linalg.py"", line 249,
 |      in solve
 |      raise LinAlgError('Singular matrix')
 |  numpy.linalg.LinAlgError: Singular matrix
 |  
 |  Method resolution order:
 |      LinAlgError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg.misc.LinAlgError,linalg.misc,LinAlgError,"Python Library Documentation: class LinAlgError in module numpy.linalg.linalg

class LinAlgError(builtins.Exception)
 |  Generic Python-exception-derived object raised by linalg functions.
 |  
 |  General purpose exception class, derived from Python's exception.Exception
 |  class, programmatically raised in linalg functions when a Linear
 |  Algebra-related condition would prevent further correct execution of the
 |  function.
 |  
 |  Parameters
 |  ----------
 |  None
 |  
 |  Examples
 |  --------
 |  >>> from numpy import linalg as LA
 |  >>> LA.inv(np.zeros((2,2)))
 |  Traceback (most recent call last):
 |    File ""<stdin>"", line 1, in <module>
 |    File ""...linalg.py"", line 350,
 |      in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
 |    File ""...linalg.py"", line 249,
 |      in solve
 |      raise LinAlgError('Singular matrix')
 |  numpy.linalg.LinAlgError: Singular matrix
 |  
 |  Method resolution order:
 |      LinAlgError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg.misc.LinAlgWarning,linalg.misc,LinAlgWarning,"Python Library Documentation: class LinAlgWarning in module scipy.linalg.misc

class LinAlgWarning(builtins.RuntimeWarning)
 |  The warning emitted when a linear algebra related operation is close
 |  to fail conditions of the algorithm or loss of accuracy is expected.
 |  
 |  Method resolution order:
 |      LinAlgWarning
 |      builtins.RuntimeWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.RuntimeWarning:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg.misc.LinAlgWarning,linalg.misc,LinAlgWarning,"Python Library Documentation: class LinAlgWarning in module scipy.linalg.misc

class LinAlgWarning(builtins.RuntimeWarning)
 |  The warning emitted when a linear algebra related operation is close
 |  to fail conditions of the algorithm or loss of accuracy is expected.
 |  
 |  Method resolution order:
 |      LinAlgWarning
 |      builtins.RuntimeWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |  
 |  Data descriptors defined here:
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.RuntimeWarning:
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |  
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |  
 |  __setstate__(...)
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |  
 |  __cause__
 |      exception cause
 |  
 |  __context__
 |      exception context
 |  
 |  __dict__
 |  
 |  __suppress_context__
 |  
 |  __traceback__
 |  
 |  args
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg.misc._datacopied,linalg.misc,_datacopied,"Python Library Documentation: function _datacopied in module scipy.linalg.misc

_datacopied(arr, original)
    Strict check for `arr` not sharing any data with `original`,
    under the assumption that arr = asarray(original)
",function,"('(arr, original)',)",scipy,1.1.0,scipy.linalg.misc._datacopied,linalg.misc,_datacopied,"Python Library Documentation: function _datacopied in module scipy.linalg.misc

_datacopied(arr, original)
    Strict check for `arr` not sharing any data with `original`,
    under the assumption that arr = asarray(original)
",function,"('arr', 'original')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(arr, original)',)"
scipy,1.1.0,scipy.linalg.misc.get_blas_funcs,linalg.misc,get_blas_funcs,"Python Library Documentation: function get_blas_funcs in module scipy.linalg.blas

get_blas_funcs(names, arrays=(), dtype=None)
    Return available BLAS function objects from names.
    
    Arrays are used to determine the optimal prefix of BLAS routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of BLAS functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of BLAS
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In BLAS, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively.
    The code and the dtype are stored in attributes `typecode` and `dtype`
    of the returned functions.
    
    Examples
    --------
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_gemv = LA.get_blas_funcs('gemv', (a,))
    >>> x_gemv.typecode
    'd'
    >>> x_gemv = LA.get_blas_funcs('gemv',(a*1j,))
    >>> x_gemv.typecode
    'z'
",function,"('(names, arrays=(), dtype=None)',)",scipy,1.1.0,scipy.linalg.misc.get_blas_funcs,linalg.misc,get_blas_funcs,"Python Library Documentation: function get_blas_funcs in module scipy.linalg.blas

get_blas_funcs(names, arrays=(), dtype=None)
    Return available BLAS function objects from names.
    
    Arrays are used to determine the optimal prefix of BLAS routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of BLAS functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of BLAS
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In BLAS, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively.
    The code and the dtype are stored in attributes `typecode` and `dtype`
    of the returned functions.
    
    Examples
    --------
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_gemv = LA.get_blas_funcs('gemv', (a,))
    >>> x_gemv.typecode
    'd'
    >>> x_gemv = LA.get_blas_funcs('gemv',(a*1j,))
    >>> x_gemv.typecode
    'z'
",function,"('names', 'arrays', 'dtype')","(nan, (), None)","(nan, 'tuple', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(names, arrays=(), dtype=None)',)"
scipy,1.1.0,scipy.linalg.misc.get_lapack_funcs,linalg.misc,get_lapack_funcs,"Python Library Documentation: function get_lapack_funcs in module scipy.linalg.lapack

get_lapack_funcs(names, arrays=(), dtype=None)
    Return available LAPACK function objects from names.
    
    Arrays are used to determine the optimal prefix of LAPACK routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of LAPACK functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of LAPACK
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In LAPACK, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively, and
    are stored in attribute ``typecode`` of the returned functions.
    
    Examples
    --------
    Suppose we would like to use '?lange' routine which computes the selected
    norm of an array. We pass our array in order to get the correct 'lange'
    flavor.
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_lange = LA.get_lapack_funcs('lange', (a,))
    >>> x_lange.typecode
    'd'
    >>> x_lange = LA.get_lapack_funcs('lange',(a*1j,))
    >>> x_lange.typecode
    'z'
    
    Several LAPACK routines work best when its internal WORK array has
    the optimal size (big enough for fast computation and small enough to
    avoid waste of memory). This size is determined also by a dedicated query
    to the function which is often wrapped as a standalone function and
    commonly denoted as ``###_lwork``. Below is an example for ``?sysv``
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(1000,1000)
    >>> b = np.random.rand(1000,1)*1j
    >>> # We pick up zsysv and zsysv_lwork due to b array
    ... xsysv, xlwork = LA.get_lapack_funcs(('sysv', 'sysv_lwork'), (a, b))
    >>> opt_lwork, _ = xlwork(a.shape[0])  # returns a complex for 'z' prefix
    >>> udut, ipiv, x, info = xsysv(a, b, lwork=int(opt_lwork.real))
",function,"('(names, arrays=(), dtype=None)',)",scipy,1.1.0,scipy.linalg.misc.get_lapack_funcs,linalg.misc,get_lapack_funcs,"Python Library Documentation: function get_lapack_funcs in module scipy.linalg.lapack

get_lapack_funcs(names, arrays=(), dtype=None)
    Return available LAPACK function objects from names.
    
    Arrays are used to determine the optimal prefix of LAPACK routines.
    
    Parameters
    ----------
    names : str or sequence of str
        Name(s) of LAPACK functions without type prefix.
    
    arrays : sequence of ndarrays, optional
        Arrays can be given to determine optimal prefix of LAPACK
        routines. If not given, double-precision routines will be
        used, otherwise the most generic type in arrays will be used.
    
    dtype : str or dtype, optional
        Data-type specifier. Not used if `arrays` is non-empty.
    
    Returns
    -------
    funcs : list
        List containing the found function(s).
    
    Notes
    -----
    This routine automatically chooses between Fortran/C
    interfaces. Fortran code is used whenever possible for arrays with
    column major order. In all other cases, C code is preferred.
    
    In LAPACK, the naming convention is that all functions start with a
    type prefix, which depends on the type of the principal
    matrix. These can be one of {'s', 'd', 'c', 'z'} for the numpy
    types {float32, float64, complex64, complex128} respectively, and
    are stored in attribute ``typecode`` of the returned functions.
    
    Examples
    --------
    Suppose we would like to use '?lange' routine which computes the selected
    norm of an array. We pass our array in order to get the correct 'lange'
    flavor.
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(3,2)
    >>> x_lange = LA.get_lapack_funcs('lange', (a,))
    >>> x_lange.typecode
    'd'
    >>> x_lange = LA.get_lapack_funcs('lange',(a*1j,))
    >>> x_lange.typecode
    'z'
    
    Several LAPACK routines work best when its internal WORK array has
    the optimal size (big enough for fast computation and small enough to
    avoid waste of memory). This size is determined also by a dedicated query
    to the function which is often wrapped as a standalone function and
    commonly denoted as ``###_lwork``. Below is an example for ``?sysv``
    
    >>> import scipy.linalg as LA
    >>> a = np.random.rand(1000,1000)
    >>> b = np.random.rand(1000,1)*1j
    >>> # We pick up zsysv and zsysv_lwork due to b array
    ... xsysv, xlwork = LA.get_lapack_funcs(('sysv', 'sysv_lwork'), (a, b))
    >>> opt_lwork, _ = xlwork(a.shape[0])  # returns a complex for 'z' prefix
    >>> udut, ipiv, x, info = xsysv(a, b, lwork=int(opt_lwork.real))
",function,"('names', 'arrays', 'dtype')","(nan, (), None)","(nan, 'tuple', 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(names, arrays=(), dtype=None)',)"
scipy,1.1.0,scipy.linalg.misc.norm,linalg.misc,norm,"Python Library Documentation: function norm in module scipy.linalg.misc

norm(a, ord=None, axis=None, keepdims=False)
    Matrix or vector norm.
    
    This function is able to return one of seven different matrix norms,
    or one of an infinite number of vector norms (described below), depending
    on the value of the ``ord`` parameter.
    
    Parameters
    ----------
    a : (M,) or (M, N) array_like
        Input array.  If `axis` is None, `a` must be 1-D or 2-D.
    ord : {non-zero int, inf, -inf, 'fro'}, optional
        Order of the norm (see table under ``Notes``). inf means numpy's
        `inf` object
    axis : {int, 2-tuple of ints, None}, optional
        If `axis` is an integer, it specifies the axis of `a` along which to
        compute the vector norms.  If `axis` is a 2-tuple, it specifies the
        axes that hold 2-D matrices, and the matrix norms of these matrices
        are computed.  If `axis` is None then either a vector norm (when `a`
        is 1-D) or a matrix norm (when `a` is 2-D) is returned.
    keepdims : bool, optional
        If this is set to True, the axes which are normed over are left in the
        result as dimensions with size one.  With this option the result will
        broadcast correctly against the original `a`.
    
    Returns
    -------
    n : float or ndarray
        Norm of the matrix or vector(s).
    
    Notes
    -----
    For values of ``ord <= 0``, the result is, strictly speaking, not a
    mathematical 'norm', but it may still be useful for various numerical
    purposes.
    
    The following norms can be calculated:
    
    =====  ============================  ==========================
    ord    norm for matrices             norm for vectors
    =====  ============================  ==========================
    None   Frobenius norm                2-norm
    'fro'  Frobenius norm                --
    inf    max(sum(abs(x), axis=1))      max(abs(x))
    -inf   min(sum(abs(x), axis=1))      min(abs(x))
    0      --                            sum(x != 0)
    1      max(sum(abs(x), axis=0))      as below
    -1     min(sum(abs(x), axis=0))      as below
    2      2-norm (largest sing. value)  as below
    -2     smallest singular value       as below
    other  --                            sum(abs(x)**ord)**(1./ord)
    =====  ============================  ==========================
    
    The Frobenius norm is given by [1]_:
    
        :math:`||A||_F = [\sum_{i,j} abs(a_{i,j})^2]^{1/2}`
    
    The ``axis`` and ``keepdims`` arguments are passed directly to
    ``numpy.linalg.norm`` and are only usable if they are supported
    by the version of numpy in use.
    
    References
    ----------
    .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*,
           Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15
    
    Examples
    --------
    >>> from scipy.linalg import norm
    >>> a = np.arange(9) - 4.0
    >>> a
    array([-4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.])
    >>> b = a.reshape((3, 3))
    >>> b
    array([[-4., -3., -2.],
           [-1.,  0.,  1.],
           [ 2.,  3.,  4.]])
    
    >>> norm(a)
    7.745966692414834
    >>> norm(b)
    7.745966692414834
    >>> norm(b, 'fro')
    7.745966692414834
    >>> norm(a, np.inf)
    4
    >>> norm(b, np.inf)
    9
    >>> norm(a, -np.inf)
    0
    >>> norm(b, -np.inf)
    2
    
    >>> norm(a, 1)
    20
    >>> norm(b, 1)
    7
    >>> norm(a, -1)
    -4.6566128774142013e-010
    >>> norm(b, -1)
    6
    >>> norm(a, 2)
    7.745966692414834
    >>> norm(b, 2)
    7.3484692283495345
    
    >>> norm(a, -2)
    0
    >>> norm(b, -2)
    1.8570331885190563e-016
    >>> norm(a, 3)
    5.8480354764257312
    >>> norm(a, -3)
    0
",function,"('(a, ord=None, axis=None, keepdims=False)',)",scipy,1.1.0,scipy.linalg.misc.norm,linalg.misc,norm,"Python Library Documentation: function norm in module scipy.linalg.misc

norm(a, ord=None, axis=None, keepdims=False)
    Matrix or vector norm.
    
    This function is able to return one of seven different matrix norms,
    or one of an infinite number of vector norms (described below), depending
    on the value of the ``ord`` parameter.
    
    Parameters
    ----------
    a : (M,) or (M, N) array_like
        Input array.  If `axis` is None, `a` must be 1-D or 2-D.
    ord : {non-zero int, inf, -inf, 'fro'}, optional
        Order of the norm (see table under ``Notes``). inf means numpy's
        `inf` object
    axis : {int, 2-tuple of ints, None}, optional
        If `axis` is an integer, it specifies the axis of `a` along which to
        compute the vector norms.  If `axis` is a 2-tuple, it specifies the
        axes that hold 2-D matrices, and the matrix norms of these matrices
        are computed.  If `axis` is None then either a vector norm (when `a`
        is 1-D) or a matrix norm (when `a` is 2-D) is returned.
    keepdims : bool, optional
        If this is set to True, the axes which are normed over are left in the
        result as dimensions with size one.  With this option the result will
        broadcast correctly against the original `a`.
    
    Returns
    -------
    n : float or ndarray
        Norm of the matrix or vector(s).
    
    Notes
    -----
    For values of ``ord <= 0``, the result is, strictly speaking, not a
    mathematical 'norm', but it may still be useful for various numerical
    purposes.
    
    The following norms can be calculated:
    
    =====  ============================  ==========================
    ord    norm for matrices             norm for vectors
    =====  ============================  ==========================
    None   Frobenius norm                2-norm
    'fro'  Frobenius norm                --
    inf    max(sum(abs(x), axis=1))      max(abs(x))
    -inf   min(sum(abs(x), axis=1))      min(abs(x))
    0      --                            sum(x != 0)
    1      max(sum(abs(x), axis=0))      as below
    -1     min(sum(abs(x), axis=0))      as below
    2      2-norm (largest sing. value)  as below
    -2     smallest singular value       as below
    other  --                            sum(abs(x)**ord)**(1./ord)
    =====  ============================  ==========================
    
    The Frobenius norm is given by [1]_:
    
        :math:`||A||_F = [\sum_{i,j} abs(a_{i,j})^2]^{1/2}`
    
    The ``axis`` and ``keepdims`` arguments are passed directly to
    ``numpy.linalg.norm`` and are only usable if they are supported
    by the version of numpy in use.
    
    References
    ----------
    .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*,
           Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15
    
    Examples
    --------
    >>> from scipy.linalg import norm
    >>> a = np.arange(9) - 4.0
    >>> a
    array([-4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.])
    >>> b = a.reshape((3, 3))
    >>> b
    array([[-4., -3., -2.],
           [-1.,  0.,  1.],
           [ 2.,  3.,  4.]])
    
    >>> norm(a)
    7.745966692414834
    >>> norm(b)
    7.745966692414834
    >>> norm(b, 'fro')
    7.745966692414834
    >>> norm(a, np.inf)
    4
    >>> norm(b, np.inf)
    9
    >>> norm(a, -np.inf)
    0
    >>> norm(b, -np.inf)
    2
    
    >>> norm(a, 1)
    20
    >>> norm(b, 1)
    7
    >>> norm(a, -1)
    -4.6566128774142013e-010
    >>> norm(b, -1)
    6
    >>> norm(a, 2)
    7.745966692414834
    >>> norm(b, 2)
    7.3484692283495345
    
    >>> norm(a, -2)
    0
    >>> norm(b, -2)
    1.8570331885190563e-016
    >>> norm(a, 3)
    5.8480354764257312
    >>> norm(a, -3)
    0
",function,"('a', 'ord', 'axis', 'keepdims')","(nan, None, None, False)","(nan, 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, ord=None, axis=None, keepdims=False)',)"
scipy,1.1.0,scipy.linalg.norm,linalg,norm,"Python Library Documentation: function norm in module scipy.linalg.misc

norm(a, ord=None, axis=None, keepdims=False)
    Matrix or vector norm.
    
    This function is able to return one of seven different matrix norms,
    or one of an infinite number of vector norms (described below), depending
    on the value of the ``ord`` parameter.
    
    Parameters
    ----------
    a : (M,) or (M, N) array_like
        Input array.  If `axis` is None, `a` must be 1-D or 2-D.
    ord : {non-zero int, inf, -inf, 'fro'}, optional
        Order of the norm (see table under ``Notes``). inf means numpy's
        `inf` object
    axis : {int, 2-tuple of ints, None}, optional
        If `axis` is an integer, it specifies the axis of `a` along which to
        compute the vector norms.  If `axis` is a 2-tuple, it specifies the
        axes that hold 2-D matrices, and the matrix norms of these matrices
        are computed.  If `axis` is None then either a vector norm (when `a`
        is 1-D) or a matrix norm (when `a` is 2-D) is returned.
    keepdims : bool, optional
        If this is set to True, the axes which are normed over are left in the
        result as dimensions with size one.  With this option the result will
        broadcast correctly against the original `a`.
    
    Returns
    -------
    n : float or ndarray
        Norm of the matrix or vector(s).
    
    Notes
    -----
    For values of ``ord <= 0``, the result is, strictly speaking, not a
    mathematical 'norm', but it may still be useful for various numerical
    purposes.
    
    The following norms can be calculated:
    
    =====  ============================  ==========================
    ord    norm for matrices             norm for vectors
    =====  ============================  ==========================
    None   Frobenius norm                2-norm
    'fro'  Frobenius norm                --
    inf    max(sum(abs(x), axis=1))      max(abs(x))
    -inf   min(sum(abs(x), axis=1))      min(abs(x))
    0      --                            sum(x != 0)
    1      max(sum(abs(x), axis=0))      as below
    -1     min(sum(abs(x), axis=0))      as below
    2      2-norm (largest sing. value)  as below
    -2     smallest singular value       as below
    other  --                            sum(abs(x)**ord)**(1./ord)
    =====  ============================  ==========================
    
    The Frobenius norm is given by [1]_:
    
        :math:`||A||_F = [\sum_{i,j} abs(a_{i,j})^2]^{1/2}`
    
    The ``axis`` and ``keepdims`` arguments are passed directly to
    ``numpy.linalg.norm`` and are only usable if they are supported
    by the version of numpy in use.
    
    References
    ----------
    .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*,
           Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15
    
    Examples
    --------
    >>> from scipy.linalg import norm
    >>> a = np.arange(9) - 4.0
    >>> a
    array([-4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.])
    >>> b = a.reshape((3, 3))
    >>> b
    array([[-4., -3., -2.],
           [-1.,  0.,  1.],
           [ 2.,  3.,  4.]])
    
    >>> norm(a)
    7.745966692414834
    >>> norm(b)
    7.745966692414834
    >>> norm(b, 'fro')
    7.745966692414834
    >>> norm(a, np.inf)
    4
    >>> norm(b, np.inf)
    9
    >>> norm(a, -np.inf)
    0
    >>> norm(b, -np.inf)
    2
    
    >>> norm(a, 1)
    20
    >>> norm(b, 1)
    7
    >>> norm(a, -1)
    -4.6566128774142013e-010
    >>> norm(b, -1)
    6
    >>> norm(a, 2)
    7.745966692414834
    >>> norm(b, 2)
    7.3484692283495345
    
    >>> norm(a, -2)
    0
    >>> norm(b, -2)
    1.8570331885190563e-016
    >>> norm(a, 3)
    5.8480354764257312
    >>> norm(a, -3)
    0
",function,"('(a, ord=None, axis=None, keepdims=False)',)",scipy,1.1.0,scipy.linalg.norm,linalg,norm,"Python Library Documentation: function norm in module scipy.linalg.misc

norm(a, ord=None, axis=None, keepdims=False)
    Matrix or vector norm.
    
    This function is able to return one of seven different matrix norms,
    or one of an infinite number of vector norms (described below), depending
    on the value of the ``ord`` parameter.
    
    Parameters
    ----------
    a : (M,) or (M, N) array_like
        Input array.  If `axis` is None, `a` must be 1-D or 2-D.
    ord : {non-zero int, inf, -inf, 'fro'}, optional
        Order of the norm (see table under ``Notes``). inf means numpy's
        `inf` object
    axis : {int, 2-tuple of ints, None}, optional
        If `axis` is an integer, it specifies the axis of `a` along which to
        compute the vector norms.  If `axis` is a 2-tuple, it specifies the
        axes that hold 2-D matrices, and the matrix norms of these matrices
        are computed.  If `axis` is None then either a vector norm (when `a`
        is 1-D) or a matrix norm (when `a` is 2-D) is returned.
    keepdims : bool, optional
        If this is set to True, the axes which are normed over are left in the
        result as dimensions with size one.  With this option the result will
        broadcast correctly against the original `a`.
    
    Returns
    -------
    n : float or ndarray
        Norm of the matrix or vector(s).
    
    Notes
    -----
    For values of ``ord <= 0``, the result is, strictly speaking, not a
    mathematical 'norm', but it may still be useful for various numerical
    purposes.
    
    The following norms can be calculated:
    
    =====  ============================  ==========================
    ord    norm for matrices             norm for vectors
    =====  ============================  ==========================
    None   Frobenius norm                2-norm
    'fro'  Frobenius norm                --
    inf    max(sum(abs(x), axis=1))      max(abs(x))
    -inf   min(sum(abs(x), axis=1))      min(abs(x))
    0      --                            sum(x != 0)
    1      max(sum(abs(x), axis=0))      as below
    -1     min(sum(abs(x), axis=0))      as below
    2      2-norm (largest sing. value)  as below
    -2     smallest singular value       as below
    other  --                            sum(abs(x)**ord)**(1./ord)
    =====  ============================  ==========================
    
    The Frobenius norm is given by [1]_:
    
        :math:`||A||_F = [\sum_{i,j} abs(a_{i,j})^2]^{1/2}`
    
    The ``axis`` and ``keepdims`` arguments are passed directly to
    ``numpy.linalg.norm`` and are only usable if they are supported
    by the version of numpy in use.
    
    References
    ----------
    .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*,
           Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15
    
    Examples
    --------
    >>> from scipy.linalg import norm
    >>> a = np.arange(9) - 4.0
    >>> a
    array([-4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.])
    >>> b = a.reshape((3, 3))
    >>> b
    array([[-4., -3., -2.],
           [-1.,  0.,  1.],
           [ 2.,  3.,  4.]])
    
    >>> norm(a)
    7.745966692414834
    >>> norm(b)
    7.745966692414834
    >>> norm(b, 'fro')
    7.745966692414834
    >>> norm(a, np.inf)
    4
    >>> norm(b, np.inf)
    9
    >>> norm(a, -np.inf)
    0
    >>> norm(b, -np.inf)
    2
    
    >>> norm(a, 1)
    20
    >>> norm(b, 1)
    7
    >>> norm(a, -1)
    -4.6566128774142013e-010
    >>> norm(b, -1)
    6
    >>> norm(a, 2)
    7.745966692414834
    >>> norm(b, 2)
    7.3484692283495345
    
    >>> norm(a, -2)
    0
    >>> norm(b, -2)
    1.8570331885190563e-016
    >>> norm(a, 3)
    5.8480354764257312
    >>> norm(a, -3)
    0
",function,"('a', 'ord', 'axis', 'keepdims')","(nan, None, None, False)","(nan, 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, ord=None, axis=None, keepdims=False)',)"
scipy,1.1.0,scipy.linalg.null_space,linalg,null_space,"Python Library Documentation: function null_space in module scipy.linalg.decomp_svd

null_space(A, rcond=None)
    Construct an orthonormal basis for the null space of A using SVD
    
    Parameters
    ----------
    A : (M, N) array_like
        Input array
    rcond : float, optional
        Relative condition number. Singular values ``s`` smaller than
        ``rcond * max(s)`` are considered zero.
        Default: floating point eps * max(M,N).
    
    Returns
    -------
    Z : (N, K) ndarray
        Orthonormal basis for the null space of A.
        K = dimension of effective null space, as determined by rcond
    
    See also
    --------
    svd : Singular value decomposition of a matrix
    orth : Matrix range
    
    Examples
    --------
    One-dimensional null space:
    
    >>> from scipy.linalg import null_space
    >>> A = np.array([[1, 1], [1, 1]])
    >>> ns = null_space(A)
    >>> ns * np.sign(ns[0,0])  # Remove the sign ambiguity of the vector
    array([[ 0.70710678],
           [-0.70710678]])
    
    Two-dimensional null space:
    
    >>> B = np.random.rand(3, 5)
    >>> Z = null_space(B)
    >>> Z.shape
    (5, 2)
    >>> np.allclose(B.dot(Z), 0)
    True
    
    The basis vectors are orthonormal (up to rounding error):
    
    >>> Z.T.dot(Z)
    array([[  1.00000000e+00,   6.92087741e-17],
           [  6.92087741e-17,   1.00000000e+00]])
",function,"('(A, rcond=None)',)",scipy,1.1.0,scipy.linalg.null_space,linalg,null_space,"Python Library Documentation: function null_space in module scipy.linalg.decomp_svd

null_space(A, rcond=None)
    Construct an orthonormal basis for the null space of A using SVD
    
    Parameters
    ----------
    A : (M, N) array_like
        Input array
    rcond : float, optional
        Relative condition number. Singular values ``s`` smaller than
        ``rcond * max(s)`` are considered zero.
        Default: floating point eps * max(M,N).
    
    Returns
    -------
    Z : (N, K) ndarray
        Orthonormal basis for the null space of A.
        K = dimension of effective null space, as determined by rcond
    
    See also
    --------
    svd : Singular value decomposition of a matrix
    orth : Matrix range
    
    Examples
    --------
    One-dimensional null space:
    
    >>> from scipy.linalg import null_space
    >>> A = np.array([[1, 1], [1, 1]])
    >>> ns = null_space(A)
    >>> ns * np.sign(ns[0,0])  # Remove the sign ambiguity of the vector
    array([[ 0.70710678],
           [-0.70710678]])
    
    Two-dimensional null space:
    
    >>> B = np.random.rand(3, 5)
    >>> Z = null_space(B)
    >>> Z.shape
    (5, 2)
    >>> np.allclose(B.dot(Z), 0)
    True
    
    The basis vectors are orthonormal (up to rounding error):
    
    >>> Z.T.dot(Z)
    array([[  1.00000000e+00,   6.92087741e-17],
           [  6.92087741e-17,   1.00000000e+00]])
",function,"('A', 'rcond')","(nan, None)","(nan, 'NoneType')","('arg_info', 'arg_info')","('(A, rcond=None)',)"
scipy,1.1.0,scipy.linalg.ordqz,linalg,ordqz,"Python Library Documentation: function ordqz in module scipy.linalg._decomp_qz

ordqz(A, B, sort='lhp', output='real', overwrite_a=False, overwrite_b=False, check_finite=True)
    QZ decomposition for a pair of matrices with reordering.
    
    .. versionadded:: 0.17.0
    
    Parameters
    ----------
    A : (N, N) array_like
        2d array to decompose
    B : (N, N) array_like
        2d array to decompose
    sort : {callable, 'lhp', 'rhp', 'iuc', 'ouc'}, optional
        Specifies whether the upper eigenvalues should be sorted. A
        callable may be passed that, given an ordered pair ``(alpha,
        beta)`` representing the eigenvalue ``x = (alpha/beta)``,
        returns a boolean denoting whether the eigenvalue should be
        sorted to the top-left (True). For the real matrix pairs
        ``beta`` is real while ``alpha`` can be complex, and for
        complex matrix pairs both ``alpha`` and ``beta`` can be
        complex. The callable must be able to accept a numpy
        array. Alternatively, string parameters may be used:
    
            - 'lhp'   Left-hand plane (x.real < 0.0)
            - 'rhp'   Right-hand plane (x.real > 0.0)
            - 'iuc'   Inside the unit circle (x*x.conjugate() < 1.0)
            - 'ouc'   Outside the unit circle (x*x.conjugate() > 1.0)
    
        With the predefined sorting functions, an infinite eigenvalue
        (i.e. ``alpha != 0`` and ``beta = 0``) is considered to lie in
        neither the left-hand nor the right-hand plane, but it is
        considered to lie outside the unit circle. For the eigenvalue
        ``(alpha, beta) = (0, 0)`` the predefined sorting functions
        all return `False`.
    output : str {'real','complex'}, optional
        Construct the real or complex QZ decomposition for real matrices.
        Default is 'real'.
    overwrite_a : bool, optional
        If True, the contents of A are overwritten.
    overwrite_b : bool, optional
        If True, the contents of B are overwritten.
    check_finite : bool, optional
        If true checks the elements of `A` and `B` are finite numbers. If
        false does no checking and passes matrix through to
        underlying algorithm.
    
    Returns
    -------
    AA : (N, N) ndarray
        Generalized Schur form of A.
    BB : (N, N) ndarray
        Generalized Schur form of B.
    alpha : (N,) ndarray
        alpha = alphar + alphai * 1j. See notes.
    beta : (N,) ndarray
        See notes.
    Q : (N, N) ndarray
        The left Schur vectors.
    Z : (N, N) ndarray
        The right Schur vectors.
    
    Notes
    -----
    On exit, ``(ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N``, will be the
    generalized eigenvalues.  ``ALPHAR(j) + ALPHAI(j)*i`` and
    ``BETA(j),j=1,...,N`` are the diagonals of the complex Schur form (S,T)
    that would result if the 2-by-2 diagonal blocks of the real generalized
    Schur form of (A,B) were further reduced to triangular form using complex
    unitary transformations. If ALPHAI(j) is zero, then the j-th eigenvalue is
    real; if positive, then the ``j``-th and ``(j+1)``-st eigenvalues are a
    complex conjugate pair, with ``ALPHAI(j+1)`` negative.
    
    See also
    --------
    qz
    
    Examples
    --------
    >>> from scipy.linalg import ordqz
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> B = np.array([[0, 6, 0, 0], [5, 0, 2, 1], [5, 2, 6, 6], [4, 7, 7, 7]])
    >>> AA, BB, alpha, beta, Q, Z = ordqz(A, B, sort='lhp')
    
    Since we have sorted for left half plane eigenvalues, negatives come first
    
    >>> (alpha/beta).real < 0
    array([ True,  True, False, False], dtype=bool)
",function,"(""(A, B, sort='lhp', output='real', overwrite_a=False, overwrite_b=False, check_finite=True)"",)",scipy,1.1.0,scipy.linalg.ordqz,linalg,ordqz,"Python Library Documentation: function ordqz in module scipy.linalg._decomp_qz

ordqz(A, B, sort='lhp', output='real', overwrite_a=False, overwrite_b=False, check_finite=True)
    QZ decomposition for a pair of matrices with reordering.
    
    .. versionadded:: 0.17.0
    
    Parameters
    ----------
    A : (N, N) array_like
        2d array to decompose
    B : (N, N) array_like
        2d array to decompose
    sort : {callable, 'lhp', 'rhp', 'iuc', 'ouc'}, optional
        Specifies whether the upper eigenvalues should be sorted. A
        callable may be passed that, given an ordered pair ``(alpha,
        beta)`` representing the eigenvalue ``x = (alpha/beta)``,
        returns a boolean denoting whether the eigenvalue should be
        sorted to the top-left (True). For the real matrix pairs
        ``beta`` is real while ``alpha`` can be complex, and for
        complex matrix pairs both ``alpha`` and ``beta`` can be
        complex. The callable must be able to accept a numpy
        array. Alternatively, string parameters may be used:
    
            - 'lhp'   Left-hand plane (x.real < 0.0)
            - 'rhp'   Right-hand plane (x.real > 0.0)
            - 'iuc'   Inside the unit circle (x*x.conjugate() < 1.0)
            - 'ouc'   Outside the unit circle (x*x.conjugate() > 1.0)
    
        With the predefined sorting functions, an infinite eigenvalue
        (i.e. ``alpha != 0`` and ``beta = 0``) is considered to lie in
        neither the left-hand nor the right-hand plane, but it is
        considered to lie outside the unit circle. For the eigenvalue
        ``(alpha, beta) = (0, 0)`` the predefined sorting functions
        all return `False`.
    output : str {'real','complex'}, optional
        Construct the real or complex QZ decomposition for real matrices.
        Default is 'real'.
    overwrite_a : bool, optional
        If True, the contents of A are overwritten.
    overwrite_b : bool, optional
        If True, the contents of B are overwritten.
    check_finite : bool, optional
        If true checks the elements of `A` and `B` are finite numbers. If
        false does no checking and passes matrix through to
        underlying algorithm.
    
    Returns
    -------
    AA : (N, N) ndarray
        Generalized Schur form of A.
    BB : (N, N) ndarray
        Generalized Schur form of B.
    alpha : (N,) ndarray
        alpha = alphar + alphai * 1j. See notes.
    beta : (N,) ndarray
        See notes.
    Q : (N, N) ndarray
        The left Schur vectors.
    Z : (N, N) ndarray
        The right Schur vectors.
    
    Notes
    -----
    On exit, ``(ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N``, will be the
    generalized eigenvalues.  ``ALPHAR(j) + ALPHAI(j)*i`` and
    ``BETA(j),j=1,...,N`` are the diagonals of the complex Schur form (S,T)
    that would result if the 2-by-2 diagonal blocks of the real generalized
    Schur form of (A,B) were further reduced to triangular form using complex
    unitary transformations. If ALPHAI(j) is zero, then the j-th eigenvalue is
    real; if positive, then the ``j``-th and ``(j+1)``-st eigenvalues are a
    complex conjugate pair, with ``ALPHAI(j+1)`` negative.
    
    See also
    --------
    qz
    
    Examples
    --------
    >>> from scipy.linalg import ordqz
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> B = np.array([[0, 6, 0, 0], [5, 0, 2, 1], [5, 2, 6, 6], [4, 7, 7, 7]])
    >>> AA, BB, alpha, beta, Q, Z = ordqz(A, B, sort='lhp')
    
    Since we have sorted for left half plane eigenvalues, negatives come first
    
    >>> (alpha/beta).real < 0
    array([ True,  True, False, False], dtype=bool)
",function,"('A', 'B', 'sort', 'output', 'overwrite_a', 'overwrite_b', 'check_finite')","(nan, nan, 'lhp', 'real', False, False, True)","(nan, nan, 'str', 'str', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(A, B, sort='lhp', output='real', overwrite_a=False, overwrite_b=False, check_finite=True)"",)"
scipy,1.1.0,scipy.linalg.orth,linalg,orth,"Python Library Documentation: function orth in module scipy.linalg.decomp_svd

orth(A, rcond=None)
    Construct an orthonormal basis for the range of A using SVD
    
    Parameters
    ----------
    A : (M, N) array_like
        Input array
    rcond : float, optional
        Relative condition number. Singular values ``s`` smaller than
        ``rcond * max(s)`` are considered zero.
        Default: floating point eps * max(M,N).
    
    Returns
    -------
    Q : (M, K) ndarray
        Orthonormal basis for the range of A.
        K = effective rank of A, as determined by rcond
    
    See also
    --------
    svd : Singular value decomposition of a matrix
    null_space : Matrix null space
    
    Examples
    --------
    >>> from scipy.linalg import orth
    >>> A = np.array([[2, 0, 0], [0, 5, 0]])  # rank 2 array
    >>> orth(A)
    array([[0., 1.],
           [1., 0.]])
    >>> orth(A.T)
    array([[0., 1.],
           [1., 0.],
           [0., 0.]])
",function,"('(A, rcond=None)',)",scipy,1.1.0,scipy.linalg.orth,linalg,orth,"Python Library Documentation: function orth in module scipy.linalg.decomp_svd

orth(A, rcond=None)
    Construct an orthonormal basis for the range of A using SVD
    
    Parameters
    ----------
    A : (M, N) array_like
        Input array
    rcond : float, optional
        Relative condition number. Singular values ``s`` smaller than
        ``rcond * max(s)`` are considered zero.
        Default: floating point eps * max(M,N).
    
    Returns
    -------
    Q : (M, K) ndarray
        Orthonormal basis for the range of A.
        K = effective rank of A, as determined by rcond
    
    See also
    --------
    svd : Singular value decomposition of a matrix
    null_space : Matrix null space
    
    Examples
    --------
    >>> from scipy.linalg import orth
    >>> A = np.array([[2, 0, 0], [0, 5, 0]])  # rank 2 array
    >>> orth(A)
    array([[0., 1.],
           [1., 0.]])
    >>> orth(A.T)
    array([[0., 1.],
           [1., 0.],
           [0., 0.]])
",function,"('A', 'rcond')","(nan, None)","(nan, 'NoneType')","('arg_info', 'arg_info')","('(A, rcond=None)',)"
scipy,1.1.0,scipy.linalg.orthogonal_procrustes,linalg,orthogonal_procrustes,"Python Library Documentation: function orthogonal_procrustes in module scipy.linalg._procrustes

orthogonal_procrustes(A, B, check_finite=True)
    Compute the matrix solution of the orthogonal Procrustes problem.
    
    Given matrices A and B of equal shape, find an orthogonal matrix R
    that most closely maps A to B using the algorithm given in [1]_.
    
    Parameters
    ----------
    A : (M, N) array_like
        Matrix to be mapped.
    B : (M, N) array_like
        Target matrix.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    R : (N, N) ndarray
        The matrix solution of the orthogonal Procrustes problem.
        Minimizes the Frobenius norm of ``(A @ R) - B``, subject to
        ``R.T @ R = I``.
    scale : float
        Sum of the singular values of ``A.T @ B``.
    
    Raises
    ------
    ValueError
        If the input array shapes don't match or if check_finite is True and
        the arrays contain Inf or NaN.
    
    Notes
    -----
    Note that unlike higher level Procrustes analyses of spatial data, this
    function only uses orthogonal transformations like rotations and
    reflections, and it does not use scaling or translation.
    
    .. versionadded:: 0.15.0
    
    References
    ----------
    .. [1] Peter H. Schonemann, ""A generalized solution of the orthogonal
           Procrustes problem"", Psychometrica -- Vol. 31, No. 1, March, 1996.
    
    Examples
    --------
    >>> from scipy.linalg import orthogonal_procrustes
    >>> A = np.array([[ 2,  0,  1], [-2,  0,  0]])
    
    Flip the order of columns and check for the anti-diagonal mapping
    
    >>> R, sca = orthogonal_procrustes(A, np.fliplr(A))
    >>> R
    array([[-5.34384992e-17,  0.00000000e+00,  1.00000000e+00],
           [ 0.00000000e+00,  1.00000000e+00,  0.00000000e+00],
           [ 1.00000000e+00,  0.00000000e+00, -7.85941422e-17]])
    >>> sca
    9.0
",function,"('(A, B, check_finite=True)',)",scipy,1.1.0,scipy.linalg.orthogonal_procrustes,linalg,orthogonal_procrustes,"Python Library Documentation: function orthogonal_procrustes in module scipy.linalg._procrustes

orthogonal_procrustes(A, B, check_finite=True)
    Compute the matrix solution of the orthogonal Procrustes problem.
    
    Given matrices A and B of equal shape, find an orthogonal matrix R
    that most closely maps A to B using the algorithm given in [1]_.
    
    Parameters
    ----------
    A : (M, N) array_like
        Matrix to be mapped.
    B : (M, N) array_like
        Target matrix.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    R : (N, N) ndarray
        The matrix solution of the orthogonal Procrustes problem.
        Minimizes the Frobenius norm of ``(A @ R) - B``, subject to
        ``R.T @ R = I``.
    scale : float
        Sum of the singular values of ``A.T @ B``.
    
    Raises
    ------
    ValueError
        If the input array shapes don't match or if check_finite is True and
        the arrays contain Inf or NaN.
    
    Notes
    -----
    Note that unlike higher level Procrustes analyses of spatial data, this
    function only uses orthogonal transformations like rotations and
    reflections, and it does not use scaling or translation.
    
    .. versionadded:: 0.15.0
    
    References
    ----------
    .. [1] Peter H. Schonemann, ""A generalized solution of the orthogonal
           Procrustes problem"", Psychometrica -- Vol. 31, No. 1, March, 1996.
    
    Examples
    --------
    >>> from scipy.linalg import orthogonal_procrustes
    >>> A = np.array([[ 2,  0,  1], [-2,  0,  0]])
    
    Flip the order of columns and check for the anti-diagonal mapping
    
    >>> R, sca = orthogonal_procrustes(A, np.fliplr(A))
    >>> R
    array([[-5.34384992e-17,  0.00000000e+00,  1.00000000e+00],
           [ 0.00000000e+00,  1.00000000e+00,  0.00000000e+00],
           [ 1.00000000e+00,  0.00000000e+00, -7.85941422e-17]])
    >>> sca
    9.0
",function,"('A', 'B', 'check_finite')","(nan, nan, True)","(nan, nan, 'bool')","('arg_info', 'arg_info', 'arg_info')","('(A, B, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.pascal,linalg,pascal,"Python Library Documentation: function pascal in module scipy.linalg.special_matrices

pascal(n, kind='symmetric', exact=True)
    Returns the n x n Pascal matrix.
    
    The Pascal matrix is a matrix containing the binomial coefficients as
    its elements.
    
    Parameters
    ----------
    n : int
        The size of the matrix to create; that is, the result is an n x n
        matrix.
    kind : str, optional
        Must be one of 'symmetric', 'lower', or 'upper'.
        Default is 'symmetric'.
    exact : bool, optional
        If `exact` is True, the result is either an array of type
        numpy.uint64 (if n < 35) or an object array of Python long integers.
        If `exact` is False, the coefficients in the matrix are computed using
        `scipy.special.comb` with `exact=False`.  The result will be a floating
        point array, and the values in the array will not be the exact
        coefficients, but this version is much faster than `exact=True`.
    
    Returns
    -------
    p : (n, n) ndarray
        The Pascal matrix.
    
    See Also
    --------
    invpascal
    
    Notes
    -----
    See http://en.wikipedia.org/wiki/Pascal_matrix for more information
    about Pascal matrices.
    
    .. versionadded:: 0.11.0
    
    Examples
    --------
    >>> from scipy.linalg import pascal
    >>> pascal(4)
    array([[ 1,  1,  1,  1],
           [ 1,  2,  3,  4],
           [ 1,  3,  6, 10],
           [ 1,  4, 10, 20]], dtype=uint64)
    >>> pascal(4, kind='lower')
    array([[1, 0, 0, 0],
           [1, 1, 0, 0],
           [1, 2, 1, 0],
           [1, 3, 3, 1]], dtype=uint64)
    >>> pascal(50)[-1, -1]
    25477612258980856902730428600L
    >>> from scipy.special import comb
    >>> comb(98, 49, exact=True)
    25477612258980856902730428600L
",function,"(""(n, kind='symmetric', exact=True)"",)",scipy,1.1.0,scipy.linalg.pascal,linalg,pascal,"Python Library Documentation: function pascal in module scipy.linalg.special_matrices

pascal(n, kind='symmetric', exact=True)
    Returns the n x n Pascal matrix.
    
    The Pascal matrix is a matrix containing the binomial coefficients as
    its elements.
    
    Parameters
    ----------
    n : int
        The size of the matrix to create; that is, the result is an n x n
        matrix.
    kind : str, optional
        Must be one of 'symmetric', 'lower', or 'upper'.
        Default is 'symmetric'.
    exact : bool, optional
        If `exact` is True, the result is either an array of type
        numpy.uint64 (if n < 35) or an object array of Python long integers.
        If `exact` is False, the coefficients in the matrix are computed using
        `scipy.special.comb` with `exact=False`.  The result will be a floating
        point array, and the values in the array will not be the exact
        coefficients, but this version is much faster than `exact=True`.
    
    Returns
    -------
    p : (n, n) ndarray
        The Pascal matrix.
    
    See Also
    --------
    invpascal
    
    Notes
    -----
    See http://en.wikipedia.org/wiki/Pascal_matrix for more information
    about Pascal matrices.
    
    .. versionadded:: 0.11.0
    
    Examples
    --------
    >>> from scipy.linalg import pascal
    >>> pascal(4)
    array([[ 1,  1,  1,  1],
           [ 1,  2,  3,  4],
           [ 1,  3,  6, 10],
           [ 1,  4, 10, 20]], dtype=uint64)
    >>> pascal(4, kind='lower')
    array([[1, 0, 0, 0],
           [1, 1, 0, 0],
           [1, 2, 1, 0],
           [1, 3, 3, 1]], dtype=uint64)
    >>> pascal(50)[-1, -1]
    25477612258980856902730428600L
    >>> from scipy.special import comb
    >>> comb(98, 49, exact=True)
    25477612258980856902730428600L
",function,"('n', 'kind', 'exact')","(nan, 'symmetric', True)","(nan, 'str', 'bool')","('arg_info', 'arg_info', 'arg_info')","(""(n, kind='symmetric', exact=True)"",)"
scipy,1.1.0,scipy.linalg.pinv,linalg,pinv,"Python Library Documentation: function pinv in module scipy.linalg.basic

pinv(a, cond=None, rcond=None, return_rank=False, check_finite=True)
    Compute the (Moore-Penrose) pseudo-inverse of a matrix.
    
    Calculate a generalized inverse of a matrix using a least-squares
    solver.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to be pseudo-inverted.
    cond, rcond : float, optional
        Cutoff for 'small' singular values in the least-squares solver.
        Singular values smaller than ``rcond * largest_singular_value``
        are considered zero.
    return_rank : bool, optional
        if True, return the effective rank of the matrix
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    B : (N, M) ndarray
        The pseudo-inverse of matrix `a`.
    rank : int
        The effective rank of the matrix.  Returned if return_rank == True
    
    Raises
    ------
    LinAlgError
        If computation does not converge.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.random.randn(9, 6)
    >>> B = linalg.pinv(a)
    >>> np.allclose(a, np.dot(a, np.dot(B, a)))
    True
    >>> np.allclose(B, np.dot(B, np.dot(a, B)))
    True
",function,"('(a, cond=None, rcond=None, return_rank=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.pinv,linalg,pinv,"Python Library Documentation: function pinv in module scipy.linalg.basic

pinv(a, cond=None, rcond=None, return_rank=False, check_finite=True)
    Compute the (Moore-Penrose) pseudo-inverse of a matrix.
    
    Calculate a generalized inverse of a matrix using a least-squares
    solver.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to be pseudo-inverted.
    cond, rcond : float, optional
        Cutoff for 'small' singular values in the least-squares solver.
        Singular values smaller than ``rcond * largest_singular_value``
        are considered zero.
    return_rank : bool, optional
        if True, return the effective rank of the matrix
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    B : (N, M) ndarray
        The pseudo-inverse of matrix `a`.
    rank : int
        The effective rank of the matrix.  Returned if return_rank == True
    
    Raises
    ------
    LinAlgError
        If computation does not converge.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.random.randn(9, 6)
    >>> B = linalg.pinv(a)
    >>> np.allclose(a, np.dot(a, np.dot(B, a)))
    True
    >>> np.allclose(B, np.dot(B, np.dot(a, B)))
    True
",function,"('a', 'cond', 'rcond', 'return_rank', 'check_finite')","(nan, None, None, False, True)","(nan, 'NoneType', 'NoneType', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, cond=None, rcond=None, return_rank=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.pinv2,linalg,pinv2,"Python Library Documentation: function pinv2 in module scipy.linalg.basic

pinv2(a, cond=None, rcond=None, return_rank=False, check_finite=True)
    Compute the (Moore-Penrose) pseudo-inverse of a matrix.
    
    Calculate a generalized inverse of a matrix using its
    singular-value decomposition and including all 'large' singular
    values.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to be pseudo-inverted.
    cond, rcond : float or None
        Cutoff for 'small' singular values.
        Singular values smaller than ``rcond*largest_singular_value``
        are considered zero.
        If None or -1, suitable machine precision is used.
    return_rank : bool, optional
        if True, return the effective rank of the matrix
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    B : (N, M) ndarray
        The pseudo-inverse of matrix `a`.
    rank : int
        The effective rank of the matrix.  Returned if return_rank == True
    
    Raises
    ------
    LinAlgError
        If SVD computation does not converge.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.random.randn(9, 6)
    >>> B = linalg.pinv2(a)
    >>> np.allclose(a, np.dot(a, np.dot(B, a)))
    True
    >>> np.allclose(B, np.dot(B, np.dot(a, B)))
    True
",function,"('(a, cond=None, rcond=None, return_rank=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.pinv2,linalg,pinv2,"Python Library Documentation: function pinv2 in module scipy.linalg.basic

pinv2(a, cond=None, rcond=None, return_rank=False, check_finite=True)
    Compute the (Moore-Penrose) pseudo-inverse of a matrix.
    
    Calculate a generalized inverse of a matrix using its
    singular-value decomposition and including all 'large' singular
    values.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to be pseudo-inverted.
    cond, rcond : float or None
        Cutoff for 'small' singular values.
        Singular values smaller than ``rcond*largest_singular_value``
        are considered zero.
        If None or -1, suitable machine precision is used.
    return_rank : bool, optional
        if True, return the effective rank of the matrix
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    B : (N, M) ndarray
        The pseudo-inverse of matrix `a`.
    rank : int
        The effective rank of the matrix.  Returned if return_rank == True
    
    Raises
    ------
    LinAlgError
        If SVD computation does not converge.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.random.randn(9, 6)
    >>> B = linalg.pinv2(a)
    >>> np.allclose(a, np.dot(a, np.dot(B, a)))
    True
    >>> np.allclose(B, np.dot(B, np.dot(a, B)))
    True
",function,"('a', 'cond', 'rcond', 'return_rank', 'check_finite')","(nan, None, None, False, True)","(nan, 'NoneType', 'NoneType', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, cond=None, rcond=None, return_rank=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.pinvh,linalg,pinvh,"Python Library Documentation: function pinvh in module scipy.linalg.basic

pinvh(a, cond=None, rcond=None, lower=True, return_rank=False, check_finite=True)
    Compute the (Moore-Penrose) pseudo-inverse of a Hermitian matrix.
    
    Calculate a generalized inverse of a Hermitian or real symmetric matrix
    using its eigenvalue decomposition and including all eigenvalues with
    'large' absolute value.
    
    Parameters
    ----------
    a : (N, N) array_like
        Real symmetric or complex hermetian matrix to be pseudo-inverted
    cond, rcond : float or None
        Cutoff for 'small' eigenvalues.
        Singular values smaller than rcond * largest_eigenvalue are considered
        zero.
    
        If None or -1, suitable machine precision is used.
    lower : bool, optional
        Whether the pertinent array data is taken from the lower or upper
        triangle of a. (Default: lower)
    return_rank : bool, optional
        if True, return the effective rank of the matrix
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    B : (N, N) ndarray
        The pseudo-inverse of matrix `a`.
    rank : int
        The effective rank of the matrix.  Returned if return_rank == True
    
    Raises
    ------
    LinAlgError
        If eigenvalue does not converge
    
    Examples
    --------
    >>> from scipy.linalg import pinvh
    >>> a = np.random.randn(9, 6)
    >>> a = np.dot(a, a.T)
    >>> B = pinvh(a)
    >>> np.allclose(a, np.dot(a, np.dot(B, a)))
    True
    >>> np.allclose(B, np.dot(B, np.dot(a, B)))
    True
",function,"('(a, cond=None, rcond=None, lower=True, return_rank=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.pinvh,linalg,pinvh,"Python Library Documentation: function pinvh in module scipy.linalg.basic

pinvh(a, cond=None, rcond=None, lower=True, return_rank=False, check_finite=True)
    Compute the (Moore-Penrose) pseudo-inverse of a Hermitian matrix.
    
    Calculate a generalized inverse of a Hermitian or real symmetric matrix
    using its eigenvalue decomposition and including all eigenvalues with
    'large' absolute value.
    
    Parameters
    ----------
    a : (N, N) array_like
        Real symmetric or complex hermetian matrix to be pseudo-inverted
    cond, rcond : float or None
        Cutoff for 'small' eigenvalues.
        Singular values smaller than rcond * largest_eigenvalue are considered
        zero.
    
        If None or -1, suitable machine precision is used.
    lower : bool, optional
        Whether the pertinent array data is taken from the lower or upper
        triangle of a. (Default: lower)
    return_rank : bool, optional
        if True, return the effective rank of the matrix
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    B : (N, N) ndarray
        The pseudo-inverse of matrix `a`.
    rank : int
        The effective rank of the matrix.  Returned if return_rank == True
    
    Raises
    ------
    LinAlgError
        If eigenvalue does not converge
    
    Examples
    --------
    >>> from scipy.linalg import pinvh
    >>> a = np.random.randn(9, 6)
    >>> a = np.dot(a, a.T)
    >>> B = pinvh(a)
    >>> np.allclose(a, np.dot(a, np.dot(B, a)))
    True
    >>> np.allclose(B, np.dot(B, np.dot(a, B)))
    True
",function,"('a', 'cond', 'rcond', 'lower', 'return_rank', 'check_finite')","(nan, None, None, True, False, True)","(nan, 'NoneType', 'NoneType', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, cond=None, rcond=None, lower=True, return_rank=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.polar,linalg,polar,"Python Library Documentation: function polar in module scipy.linalg._decomp_polar

polar(a, side='right')
    Compute the polar decomposition.
    
    Returns the factors of the polar decomposition [1]_ `u` and `p` such
    that ``a = up`` (if `side` is ""right"") or ``a = pu`` (if `side` is
    ""left""), where `p` is positive semidefinite.  Depending on the shape
    of `a`, either the rows or columns of `u` are orthonormal.  When `a`
    is a square array, `u` is a square unitary array.  When `a` is not
    square, the ""canonical polar decomposition"" [2]_ is computed.
    
    Parameters
    ----------
    a : (m, n) array_like
        The array to be factored.
    side : {'left', 'right'}, optional
        Determines whether a right or left polar decomposition is computed.
        If `side` is ""right"", then ``a = up``.  If `side` is ""left"",  then
        ``a = pu``.  The default is ""right"".
    
    Returns
    -------
    u : (m, n) ndarray
        If `a` is square, then `u` is unitary.  If m > n, then the columns
        of `a` are orthonormal, and if m < n, then the rows of `u` are
        orthonormal.
    p : ndarray
        `p` is Hermitian positive semidefinite.  If `a` is nonsingular, `p`
        is positive definite.  The shape of `p` is (n, n) or (m, m), depending
        on whether `side` is ""right"" or ""left"", respectively.
    
    References
    ----------
    .. [1] R. A. Horn and C. R. Johnson, ""Matrix Analysis"", Cambridge
           University Press, 1985.
    .. [2] N. J. Higham, ""Functions of Matrices: Theory and Computation"",
           SIAM, 2008.
    
    Examples
    --------
    >>> from scipy.linalg import polar
    >>> a = np.array([[1, -1], [2, 4]])
    >>> u, p = polar(a)
    >>> u
    array([[ 0.85749293, -0.51449576],
           [ 0.51449576,  0.85749293]])
    >>> p
    array([[ 1.88648444,  1.2004901 ],
           [ 1.2004901 ,  3.94446746]])
    
    A non-square example, with m < n:
    
    >>> b = np.array([[0.5, 1, 2], [1.5, 3, 4]])
    >>> u, p = polar(b)
    >>> u
    array([[-0.21196618, -0.42393237,  0.88054056],
           [ 0.39378971,  0.78757942,  0.4739708 ]])
    >>> p
    array([[ 0.48470147,  0.96940295,  1.15122648],
           [ 0.96940295,  1.9388059 ,  2.30245295],
           [ 1.15122648,  2.30245295,  3.65696431]])
    >>> u.dot(p)   # Verify the decomposition.
    array([[ 0.5,  1. ,  2. ],
           [ 1.5,  3. ,  4. ]])
    >>> u.dot(u.T)   # The rows of u are orthonormal.
    array([[  1.00000000e+00,  -2.07353665e-17],
           [ -2.07353665e-17,   1.00000000e+00]])
    
    Another non-square example, with m > n:
    
    >>> c = b.T
    >>> u, p = polar(c)
    >>> u
    array([[-0.21196618,  0.39378971],
           [-0.42393237,  0.78757942],
           [ 0.88054056,  0.4739708 ]])
    >>> p
    array([[ 1.23116567,  1.93241587],
           [ 1.93241587,  4.84930602]])
    >>> u.dot(p)   # Verify the decomposition.
    array([[ 0.5,  1.5],
           [ 1. ,  3. ],
           [ 2. ,  4. ]])
    >>> u.T.dot(u)  # The columns of u are orthonormal.
    array([[  1.00000000e+00,  -1.26363763e-16],
           [ -1.26363763e-16,   1.00000000e+00]])
",function,"(""(a, side='right')"",)",scipy,1.1.0,scipy.linalg.polar,linalg,polar,"Python Library Documentation: function polar in module scipy.linalg._decomp_polar

polar(a, side='right')
    Compute the polar decomposition.
    
    Returns the factors of the polar decomposition [1]_ `u` and `p` such
    that ``a = up`` (if `side` is ""right"") or ``a = pu`` (if `side` is
    ""left""), where `p` is positive semidefinite.  Depending on the shape
    of `a`, either the rows or columns of `u` are orthonormal.  When `a`
    is a square array, `u` is a square unitary array.  When `a` is not
    square, the ""canonical polar decomposition"" [2]_ is computed.
    
    Parameters
    ----------
    a : (m, n) array_like
        The array to be factored.
    side : {'left', 'right'}, optional
        Determines whether a right or left polar decomposition is computed.
        If `side` is ""right"", then ``a = up``.  If `side` is ""left"",  then
        ``a = pu``.  The default is ""right"".
    
    Returns
    -------
    u : (m, n) ndarray
        If `a` is square, then `u` is unitary.  If m > n, then the columns
        of `a` are orthonormal, and if m < n, then the rows of `u` are
        orthonormal.
    p : ndarray
        `p` is Hermitian positive semidefinite.  If `a` is nonsingular, `p`
        is positive definite.  The shape of `p` is (n, n) or (m, m), depending
        on whether `side` is ""right"" or ""left"", respectively.
    
    References
    ----------
    .. [1] R. A. Horn and C. R. Johnson, ""Matrix Analysis"", Cambridge
           University Press, 1985.
    .. [2] N. J. Higham, ""Functions of Matrices: Theory and Computation"",
           SIAM, 2008.
    
    Examples
    --------
    >>> from scipy.linalg import polar
    >>> a = np.array([[1, -1], [2, 4]])
    >>> u, p = polar(a)
    >>> u
    array([[ 0.85749293, -0.51449576],
           [ 0.51449576,  0.85749293]])
    >>> p
    array([[ 1.88648444,  1.2004901 ],
           [ 1.2004901 ,  3.94446746]])
    
    A non-square example, with m < n:
    
    >>> b = np.array([[0.5, 1, 2], [1.5, 3, 4]])
    >>> u, p = polar(b)
    >>> u
    array([[-0.21196618, -0.42393237,  0.88054056],
           [ 0.39378971,  0.78757942,  0.4739708 ]])
    >>> p
    array([[ 0.48470147,  0.96940295,  1.15122648],
           [ 0.96940295,  1.9388059 ,  2.30245295],
           [ 1.15122648,  2.30245295,  3.65696431]])
    >>> u.dot(p)   # Verify the decomposition.
    array([[ 0.5,  1. ,  2. ],
           [ 1.5,  3. ,  4. ]])
    >>> u.dot(u.T)   # The rows of u are orthonormal.
    array([[  1.00000000e+00,  -2.07353665e-17],
           [ -2.07353665e-17,   1.00000000e+00]])
    
    Another non-square example, with m > n:
    
    >>> c = b.T
    >>> u, p = polar(c)
    >>> u
    array([[-0.21196618,  0.39378971],
           [-0.42393237,  0.78757942],
           [ 0.88054056,  0.4739708 ]])
    >>> p
    array([[ 1.23116567,  1.93241587],
           [ 1.93241587,  4.84930602]])
    >>> u.dot(p)   # Verify the decomposition.
    array([[ 0.5,  1.5],
           [ 1. ,  3. ],
           [ 2. ,  4. ]])
    >>> u.T.dot(u)  # The columns of u are orthonormal.
    array([[  1.00000000e+00,  -1.26363763e-16],
           [ -1.26363763e-16,   1.00000000e+00]])
",function,"('a', 'side')","(nan, 'right')","(nan, 'str')","('arg_info', 'arg_info')","(""(a, side='right')"",)"
scipy,1.1.0,scipy.linalg.qr,linalg,qr,"Python Library Documentation: function qr in module scipy.linalg.decomp_qr

qr(a, overwrite_a=False, lwork=None, mode='full', pivoting=False, check_finite=True)
    Compute QR decomposition of a matrix.
    
    Calculate the decomposition ``A = Q R`` where Q is unitary/orthogonal
    and R upper triangular.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to be decomposed
    overwrite_a : bool, optional
        Whether data in a is overwritten (may improve performance)
    lwork : int, optional
        Work array size, lwork >= a.shape[1]. If None or -1, an optimal size
        is computed.
    mode : {'full', 'r', 'economic', 'raw'}, optional
        Determines what information is to be returned: either both Q and R
        ('full', default), only R ('r') or both Q and R but computed in
        economy-size ('economic', see Notes). The final option 'raw'
        (added in Scipy 0.11) makes the function return two matrices
        (Q, TAU) in the internal format used by LAPACK.
    pivoting : bool, optional
        Whether or not factorization should include pivoting for rank-revealing
        qr decomposition. If pivoting, compute the decomposition
        ``A P = Q R`` as above, but where P is chosen such that the diagonal
        of R is non-increasing.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    Q : float or complex ndarray
        Of shape (M, M), or (M, K) for ``mode='economic'``.  Not returned
        if ``mode='r'``.
    R : float or complex ndarray
        Of shape (M, N), or (K, N) for ``mode='economic'``.  ``K = min(M, N)``.
    P : int ndarray
        Of shape (N,) for ``pivoting=True``. Not returned if
        ``pivoting=False``.
    
    Raises
    ------
    LinAlgError
        Raised if decomposition fails
    
    Notes
    -----
    This is an interface to the LAPACK routines dgeqrf, zgeqrf,
    dorgqr, zungqr, dgeqp3, and zgeqp3.
    
    If ``mode=economic``, the shapes of Q and R are (M, K) and (K, N) instead
    of (M,M) and (M,N), with ``K=min(M,N)``.
    
    Examples
    --------
    >>> from scipy import random, linalg, dot, diag, all, allclose
    >>> a = random.randn(9, 6)
    
    >>> q, r = linalg.qr(a)
    >>> allclose(a, np.dot(q, r))
    True
    >>> q.shape, r.shape
    ((9, 9), (9, 6))
    
    >>> r2 = linalg.qr(a, mode='r')
    >>> allclose(r, r2)
    True
    
    >>> q3, r3 = linalg.qr(a, mode='economic')
    >>> q3.shape, r3.shape
    ((9, 6), (6, 6))
    
    >>> q4, r4, p4 = linalg.qr(a, pivoting=True)
    >>> d = abs(diag(r4))
    >>> all(d[1:] <= d[:-1])
    True
    >>> allclose(a[:, p4], dot(q4, r4))
    True
    >>> q4.shape, r4.shape, p4.shape
    ((9, 9), (9, 6), (6,))
    
    >>> q5, r5, p5 = linalg.qr(a, mode='economic', pivoting=True)
    >>> q5.shape, r5.shape, p5.shape
    ((9, 6), (6, 6), (6,))
",function,"(""(a, overwrite_a=False, lwork=None, mode='full', pivoting=False, check_finite=True)"",)",scipy,1.1.0,scipy.linalg.qr,linalg,qr,"Python Library Documentation: function qr in module scipy.linalg.decomp_qr

qr(a, overwrite_a=False, lwork=None, mode='full', pivoting=False, check_finite=True)
    Compute QR decomposition of a matrix.
    
    Calculate the decomposition ``A = Q R`` where Q is unitary/orthogonal
    and R upper triangular.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to be decomposed
    overwrite_a : bool, optional
        Whether data in a is overwritten (may improve performance)
    lwork : int, optional
        Work array size, lwork >= a.shape[1]. If None or -1, an optimal size
        is computed.
    mode : {'full', 'r', 'economic', 'raw'}, optional
        Determines what information is to be returned: either both Q and R
        ('full', default), only R ('r') or both Q and R but computed in
        economy-size ('economic', see Notes). The final option 'raw'
        (added in Scipy 0.11) makes the function return two matrices
        (Q, TAU) in the internal format used by LAPACK.
    pivoting : bool, optional
        Whether or not factorization should include pivoting for rank-revealing
        qr decomposition. If pivoting, compute the decomposition
        ``A P = Q R`` as above, but where P is chosen such that the diagonal
        of R is non-increasing.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    Q : float or complex ndarray
        Of shape (M, M), or (M, K) for ``mode='economic'``.  Not returned
        if ``mode='r'``.
    R : float or complex ndarray
        Of shape (M, N), or (K, N) for ``mode='economic'``.  ``K = min(M, N)``.
    P : int ndarray
        Of shape (N,) for ``pivoting=True``. Not returned if
        ``pivoting=False``.
    
    Raises
    ------
    LinAlgError
        Raised if decomposition fails
    
    Notes
    -----
    This is an interface to the LAPACK routines dgeqrf, zgeqrf,
    dorgqr, zungqr, dgeqp3, and zgeqp3.
    
    If ``mode=economic``, the shapes of Q and R are (M, K) and (K, N) instead
    of (M,M) and (M,N), with ``K=min(M,N)``.
    
    Examples
    --------
    >>> from scipy import random, linalg, dot, diag, all, allclose
    >>> a = random.randn(9, 6)
    
    >>> q, r = linalg.qr(a)
    >>> allclose(a, np.dot(q, r))
    True
    >>> q.shape, r.shape
    ((9, 9), (9, 6))
    
    >>> r2 = linalg.qr(a, mode='r')
    >>> allclose(r, r2)
    True
    
    >>> q3, r3 = linalg.qr(a, mode='economic')
    >>> q3.shape, r3.shape
    ((9, 6), (6, 6))
    
    >>> q4, r4, p4 = linalg.qr(a, pivoting=True)
    >>> d = abs(diag(r4))
    >>> all(d[1:] <= d[:-1])
    True
    >>> allclose(a[:, p4], dot(q4, r4))
    True
    >>> q4.shape, r4.shape, p4.shape
    ((9, 9), (9, 6), (6,))
    
    >>> q5, r5, p5 = linalg.qr(a, mode='economic', pivoting=True)
    >>> q5.shape, r5.shape, p5.shape
    ((9, 6), (6, 6), (6,))
",function,"('a', 'overwrite_a', 'lwork', 'mode', 'pivoting', 'check_finite')","(nan, False, None, 'full', False, True)","(nan, 'bool', 'NoneType', 'str', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a, overwrite_a=False, lwork=None, mode='full', pivoting=False, check_finite=True)"",)"
scipy,1.1.0,scipy.linalg.qr_multiply,linalg,qr_multiply,"Python Library Documentation: function qr_multiply in module scipy.linalg.decomp_qr

qr_multiply(a, c, mode='right', pivoting=False, conjugate=False, overwrite_a=False, overwrite_c=False)
    Calculate the QR decomposition and multiply Q with a matrix.
    
    Calculate the decomposition ``A = Q R`` where Q is unitary/orthogonal
    and R upper triangular. Multiply Q with a vector or a matrix c.
    
    Parameters
    ----------
    a : (M, N), array_like
        Input array
    c : array_like
        Input array to be multiplied by ``q``.
    mode : {'left', 'right'}, optional
        ``Q @ c`` is returned if mode is 'left', ``c @ Q`` is returned if
        mode is 'right'.
        The shape of c must be appropriate for the matrix multiplications,
        if mode is 'left', ``min(a.shape) == c.shape[0]``,
        if mode is 'right', ``a.shape[0] == c.shape[1]``.
    pivoting : bool, optional
        Whether or not factorization should include pivoting for rank-revealing
        qr decomposition, see the documentation of qr.
    conjugate : bool, optional
        Whether Q should be complex-conjugated. This might be faster
        than explicit conjugation.
    overwrite_a : bool, optional
        Whether data in a is overwritten (may improve performance)
    overwrite_c : bool, optional
        Whether data in c is overwritten (may improve performance).
        If this is used, c must be big enough to keep the result,
        i.e. ``c.shape[0]`` = ``a.shape[0]`` if mode is 'left'.
    
    Returns
    -------
    CQ : ndarray
        The product of ``Q`` and ``c``.
    R : (K, N), ndarray
        R array of the resulting QR factorization where ``K = min(M, N)``.
    P : (N,) ndarray
        Integer pivot array. Only returned when ``pivoting=True``.
    
    Raises
    ------
    LinAlgError
        Raised if QR decomposition fails.
    
    Notes
    -----
    This is an interface to the LAPACK routines ``?GEQRF``, ``?ORMQR``,
    ``?UNMQR``, and ``?GEQP3``.
    
    .. versionadded:: 0.11.0
    
    Examples
    --------
    >>> from scipy.linalg import qr_multiply, qr
    >>> A = np.array([[1, 3, 3], [2, 3, 2], [2, 3, 3], [1, 3, 2]])
    >>> qc, r1, piv1 = qr_multiply(A, 2*np.eye(4), pivoting=1)
    >>> qc
    array([[-1.,  1., -1.],
           [-1., -1.,  1.],
           [-1., -1., -1.],
           [-1.,  1.,  1.]])
    >>> r1
    array([[-6., -3., -5.            ],
           [ 0., -1., -1.11022302e-16],
           [ 0.,  0., -1.            ]])
    >>> piv1
    array([1, 0, 2], dtype=int32)
    >>> q2, r2, piv2 = qr(A, mode='economic', pivoting=1)
    >>> np.allclose(2*q2 - qc, np.zeros((4, 3)))
    True
",function,"(""(a, c, mode='right', pivoting=False, conjugate=False, overwrite_a=False, overwrite_c=False)"",)",scipy,1.1.0,scipy.linalg.qr_multiply,linalg,qr_multiply,"Python Library Documentation: function qr_multiply in module scipy.linalg.decomp_qr

qr_multiply(a, c, mode='right', pivoting=False, conjugate=False, overwrite_a=False, overwrite_c=False)
    Calculate the QR decomposition and multiply Q with a matrix.
    
    Calculate the decomposition ``A = Q R`` where Q is unitary/orthogonal
    and R upper triangular. Multiply Q with a vector or a matrix c.
    
    Parameters
    ----------
    a : (M, N), array_like
        Input array
    c : array_like
        Input array to be multiplied by ``q``.
    mode : {'left', 'right'}, optional
        ``Q @ c`` is returned if mode is 'left', ``c @ Q`` is returned if
        mode is 'right'.
        The shape of c must be appropriate for the matrix multiplications,
        if mode is 'left', ``min(a.shape) == c.shape[0]``,
        if mode is 'right', ``a.shape[0] == c.shape[1]``.
    pivoting : bool, optional
        Whether or not factorization should include pivoting for rank-revealing
        qr decomposition, see the documentation of qr.
    conjugate : bool, optional
        Whether Q should be complex-conjugated. This might be faster
        than explicit conjugation.
    overwrite_a : bool, optional
        Whether data in a is overwritten (may improve performance)
    overwrite_c : bool, optional
        Whether data in c is overwritten (may improve performance).
        If this is used, c must be big enough to keep the result,
        i.e. ``c.shape[0]`` = ``a.shape[0]`` if mode is 'left'.
    
    Returns
    -------
    CQ : ndarray
        The product of ``Q`` and ``c``.
    R : (K, N), ndarray
        R array of the resulting QR factorization where ``K = min(M, N)``.
    P : (N,) ndarray
        Integer pivot array. Only returned when ``pivoting=True``.
    
    Raises
    ------
    LinAlgError
        Raised if QR decomposition fails.
    
    Notes
    -----
    This is an interface to the LAPACK routines ``?GEQRF``, ``?ORMQR``,
    ``?UNMQR``, and ``?GEQP3``.
    
    .. versionadded:: 0.11.0
    
    Examples
    --------
    >>> from scipy.linalg import qr_multiply, qr
    >>> A = np.array([[1, 3, 3], [2, 3, 2], [2, 3, 3], [1, 3, 2]])
    >>> qc, r1, piv1 = qr_multiply(A, 2*np.eye(4), pivoting=1)
    >>> qc
    array([[-1.,  1., -1.],
           [-1., -1.,  1.],
           [-1., -1., -1.],
           [-1.,  1.,  1.]])
    >>> r1
    array([[-6., -3., -5.            ],
           [ 0., -1., -1.11022302e-16],
           [ 0.,  0., -1.            ]])
    >>> piv1
    array([1, 0, 2], dtype=int32)
    >>> q2, r2, piv2 = qr(A, mode='economic', pivoting=1)
    >>> np.allclose(2*q2 - qc, np.zeros((4, 3)))
    True
",function,"('a', 'c', 'mode', 'pivoting', 'conjugate', 'overwrite_a', 'overwrite_c')","(nan, nan, 'right', False, False, False, False)","(nan, nan, 'str', 'bool', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a, c, mode='right', pivoting=False, conjugate=False, overwrite_a=False, overwrite_c=False)"",)"
scipy,1.1.0,scipy.linalg.qz,linalg,qz,"Python Library Documentation: function qz in module scipy.linalg._decomp_qz

qz(A, B, output='real', lwork=None, sort=None, overwrite_a=False, overwrite_b=False, check_finite=True)
    QZ decomposition for generalized eigenvalues of a pair of matrices.
    
    The QZ, or generalized Schur, decomposition for a pair of N x N
    nonsymmetric matrices (A,B) is::
    
        (A,B) = (Q*AA*Z', Q*BB*Z')
    
    where AA, BB is in generalized Schur form if BB is upper-triangular
    with non-negative diagonal and AA is upper-triangular, or for real QZ
    decomposition (``output='real'``) block upper triangular with 1x1
    and 2x2 blocks.  In this case, the 1x1 blocks correspond to real
    generalized eigenvalues and 2x2 blocks are 'standardized' by making
    the corresponding elements of BB have the form::
    
        [ a 0 ]
        [ 0 b ]
    
    and the pair of corresponding 2x2 blocks in AA and BB will have a complex
    conjugate pair of generalized eigenvalues.  If (``output='complex'``) or
    A and B are complex matrices, Z' denotes the conjugate-transpose of Z.
    Q and Z are unitary matrices.
    
    Parameters
    ----------
    A : (N, N) array_like
        2d array to decompose
    B : (N, N) array_like
        2d array to decompose
    output : {'real', 'complex'}, optional
        Construct the real or complex QZ decomposition for real matrices.
        Default is 'real'.
    lwork : int, optional
        Work array size.  If None or -1, it is automatically computed.
    sort : {None, callable, 'lhp', 'rhp', 'iuc', 'ouc'}, optional
        NOTE: THIS INPUT IS DISABLED FOR NOW. Use ordqz instead.
    
        Specifies whether the upper eigenvalues should be sorted.  A callable
        may be passed that, given a eigenvalue, returns a boolean denoting
        whether the eigenvalue should be sorted to the top-left (True). For
        real matrix pairs, the sort function takes three real arguments
        (alphar, alphai, beta). The eigenvalue
        ``x = (alphar + alphai*1j)/beta``.  For complex matrix pairs or
        output='complex', the sort function takes two complex arguments
        (alpha, beta). The eigenvalue ``x = (alpha/beta)``.  Alternatively,
        string parameters may be used:
    
            - 'lhp'   Left-hand plane (x.real < 0.0)
            - 'rhp'   Right-hand plane (x.real > 0.0)
            - 'iuc'   Inside the unit circle (x*x.conjugate() < 1.0)
            - 'ouc'   Outside the unit circle (x*x.conjugate() > 1.0)
    
        Defaults to None (no sorting).
    overwrite_a : bool, optional
        Whether to overwrite data in a (may improve performance)
    overwrite_b : bool, optional
        Whether to overwrite data in b (may improve performance)
    check_finite : bool, optional
        If true checks the elements of `A` and `B` are finite numbers. If
        false does no checking and passes matrix through to
        underlying algorithm.
    
    Returns
    -------
    AA : (N, N) ndarray
        Generalized Schur form of A.
    BB : (N, N) ndarray
        Generalized Schur form of B.
    Q : (N, N) ndarray
        The left Schur vectors.
    Z : (N, N) ndarray
        The right Schur vectors.
    
    Notes
    -----
    Q is transposed versus the equivalent function in Matlab.
    
    .. versionadded:: 0.11.0
    
    Examples
    --------
    >>> from scipy import linalg
    >>> np.random.seed(1234)
    >>> A = np.arange(9).reshape((3, 3))
    >>> B = np.random.randn(3, 3)
    
    >>> AA, BB, Q, Z = linalg.qz(A, B)
    >>> AA
    array([[-13.40928183,  -4.62471562,   1.09215523],
           [  0.        ,   0.        ,   1.22805978],
           [  0.        ,   0.        ,   0.31973817]])
    >>> BB
    array([[ 0.33362547, -1.37393632,  0.02179805],
           [ 0.        ,  1.68144922,  0.74683866],
           [ 0.        ,  0.        ,  0.9258294 ]])
    >>> Q
    array([[ 0.14134727, -0.97562773,  0.16784365],
           [ 0.49835904, -0.07636948, -0.86360059],
           [ 0.85537081,  0.20571399,  0.47541828]])
    >>> Z
    array([[-0.24900855, -0.51772687,  0.81850696],
           [-0.79813178,  0.58842606,  0.12938478],
           [-0.54861681, -0.6210585 , -0.55973739]])
    
    See also
    --------
    ordqz
",function,"(""(A, B, output='real', lwork=None, sort=None, overwrite_a=False, overwrite_b=False, check_finite=True)"",)",scipy,1.1.0,scipy.linalg.qz,linalg,qz,"Python Library Documentation: function qz in module scipy.linalg._decomp_qz

qz(A, B, output='real', lwork=None, sort=None, overwrite_a=False, overwrite_b=False, check_finite=True)
    QZ decomposition for generalized eigenvalues of a pair of matrices.
    
    The QZ, or generalized Schur, decomposition for a pair of N x N
    nonsymmetric matrices (A,B) is::
    
        (A,B) = (Q*AA*Z', Q*BB*Z')
    
    where AA, BB is in generalized Schur form if BB is upper-triangular
    with non-negative diagonal and AA is upper-triangular, or for real QZ
    decomposition (``output='real'``) block upper triangular with 1x1
    and 2x2 blocks.  In this case, the 1x1 blocks correspond to real
    generalized eigenvalues and 2x2 blocks are 'standardized' by making
    the corresponding elements of BB have the form::
    
        [ a 0 ]
        [ 0 b ]
    
    and the pair of corresponding 2x2 blocks in AA and BB will have a complex
    conjugate pair of generalized eigenvalues.  If (``output='complex'``) or
    A and B are complex matrices, Z' denotes the conjugate-transpose of Z.
    Q and Z are unitary matrices.
    
    Parameters
    ----------
    A : (N, N) array_like
        2d array to decompose
    B : (N, N) array_like
        2d array to decompose
    output : {'real', 'complex'}, optional
        Construct the real or complex QZ decomposition for real matrices.
        Default is 'real'.
    lwork : int, optional
        Work array size.  If None or -1, it is automatically computed.
    sort : {None, callable, 'lhp', 'rhp', 'iuc', 'ouc'}, optional
        NOTE: THIS INPUT IS DISABLED FOR NOW. Use ordqz instead.
    
        Specifies whether the upper eigenvalues should be sorted.  A callable
        may be passed that, given a eigenvalue, returns a boolean denoting
        whether the eigenvalue should be sorted to the top-left (True). For
        real matrix pairs, the sort function takes three real arguments
        (alphar, alphai, beta). The eigenvalue
        ``x = (alphar + alphai*1j)/beta``.  For complex matrix pairs or
        output='complex', the sort function takes two complex arguments
        (alpha, beta). The eigenvalue ``x = (alpha/beta)``.  Alternatively,
        string parameters may be used:
    
            - 'lhp'   Left-hand plane (x.real < 0.0)
            - 'rhp'   Right-hand plane (x.real > 0.0)
            - 'iuc'   Inside the unit circle (x*x.conjugate() < 1.0)
            - 'ouc'   Outside the unit circle (x*x.conjugate() > 1.0)
    
        Defaults to None (no sorting).
    overwrite_a : bool, optional
        Whether to overwrite data in a (may improve performance)
    overwrite_b : bool, optional
        Whether to overwrite data in b (may improve performance)
    check_finite : bool, optional
        If true checks the elements of `A` and `B` are finite numbers. If
        false does no checking and passes matrix through to
        underlying algorithm.
    
    Returns
    -------
    AA : (N, N) ndarray
        Generalized Schur form of A.
    BB : (N, N) ndarray
        Generalized Schur form of B.
    Q : (N, N) ndarray
        The left Schur vectors.
    Z : (N, N) ndarray
        The right Schur vectors.
    
    Notes
    -----
    Q is transposed versus the equivalent function in Matlab.
    
    .. versionadded:: 0.11.0
    
    Examples
    --------
    >>> from scipy import linalg
    >>> np.random.seed(1234)
    >>> A = np.arange(9).reshape((3, 3))
    >>> B = np.random.randn(3, 3)
    
    >>> AA, BB, Q, Z = linalg.qz(A, B)
    >>> AA
    array([[-13.40928183,  -4.62471562,   1.09215523],
           [  0.        ,   0.        ,   1.22805978],
           [  0.        ,   0.        ,   0.31973817]])
    >>> BB
    array([[ 0.33362547, -1.37393632,  0.02179805],
           [ 0.        ,  1.68144922,  0.74683866],
           [ 0.        ,  0.        ,  0.9258294 ]])
    >>> Q
    array([[ 0.14134727, -0.97562773,  0.16784365],
           [ 0.49835904, -0.07636948, -0.86360059],
           [ 0.85537081,  0.20571399,  0.47541828]])
    >>> Z
    array([[-0.24900855, -0.51772687,  0.81850696],
           [-0.79813178,  0.58842606,  0.12938478],
           [-0.54861681, -0.6210585 , -0.55973739]])
    
    See also
    --------
    ordqz
",function,"('A', 'B', 'output', 'lwork', 'sort', 'overwrite_a', 'overwrite_b', 'check_finite')","(nan, nan, 'real', None, None, False, False, True)","(nan, nan, 'str', 'NoneType', 'NoneType', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(A, B, output='real', lwork=None, sort=None, overwrite_a=False, overwrite_b=False, check_finite=True)"",)"
scipy,1.1.0,scipy.linalg.rq,linalg,rq,"Python Library Documentation: function rq in module scipy.linalg.decomp_qr

rq(a, overwrite_a=False, lwork=None, mode='full', check_finite=True)
    Compute RQ decomposition of a matrix.
    
    Calculate the decomposition ``A = R Q`` where Q is unitary/orthogonal
    and R upper triangular.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to be decomposed
    overwrite_a : bool, optional
        Whether data in a is overwritten (may improve performance)
    lwork : int, optional
        Work array size, lwork >= a.shape[1]. If None or -1, an optimal size
        is computed.
    mode : {'full', 'r', 'economic'}, optional
        Determines what information is to be returned: either both Q and R
        ('full', default), only R ('r') or both Q and R but computed in
        economy-size ('economic', see Notes).
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    R : float or complex ndarray
        Of shape (M, N) or (M, K) for ``mode='economic'``.  ``K = min(M, N)``.
    Q : float or complex ndarray
        Of shape (N, N) or (K, N) for ``mode='economic'``.  Not returned
        if ``mode='r'``.
    
    Raises
    ------
    LinAlgError
        If decomposition fails.
    
    Notes
    -----
    This is an interface to the LAPACK routines sgerqf, dgerqf, cgerqf, zgerqf,
    sorgrq, dorgrq, cungrq and zungrq.
    
    If ``mode=economic``, the shapes of Q and R are (K, N) and (M, K) instead
    of (N,N) and (M,N), with ``K=min(M,N)``.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.random.randn(6, 9)
    >>> r, q = linalg.rq(a)
    >>> np.allclose(a, r @ q)
    True
    >>> r.shape, q.shape
    ((6, 9), (9, 9))
    >>> r2 = linalg.rq(a, mode='r')
    >>> np.allclose(r, r2)
    True
    >>> r3, q3 = linalg.rq(a, mode='economic')
    >>> r3.shape, q3.shape
    ((6, 6), (6, 9))
",function,"(""(a, overwrite_a=False, lwork=None, mode='full', check_finite=True)"",)",scipy,1.1.0,scipy.linalg.rq,linalg,rq,"Python Library Documentation: function rq in module scipy.linalg.decomp_qr

rq(a, overwrite_a=False, lwork=None, mode='full', check_finite=True)
    Compute RQ decomposition of a matrix.
    
    Calculate the decomposition ``A = R Q`` where Q is unitary/orthogonal
    and R upper triangular.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to be decomposed
    overwrite_a : bool, optional
        Whether data in a is overwritten (may improve performance)
    lwork : int, optional
        Work array size, lwork >= a.shape[1]. If None or -1, an optimal size
        is computed.
    mode : {'full', 'r', 'economic'}, optional
        Determines what information is to be returned: either both Q and R
        ('full', default), only R ('r') or both Q and R but computed in
        economy-size ('economic', see Notes).
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    R : float or complex ndarray
        Of shape (M, N) or (M, K) for ``mode='economic'``.  ``K = min(M, N)``.
    Q : float or complex ndarray
        Of shape (N, N) or (K, N) for ``mode='economic'``.  Not returned
        if ``mode='r'``.
    
    Raises
    ------
    LinAlgError
        If decomposition fails.
    
    Notes
    -----
    This is an interface to the LAPACK routines sgerqf, dgerqf, cgerqf, zgerqf,
    sorgrq, dorgrq, cungrq and zungrq.
    
    If ``mode=economic``, the shapes of Q and R are (K, N) and (M, K) instead
    of (N,N) and (M,N), with ``K=min(M,N)``.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> a = np.random.randn(6, 9)
    >>> r, q = linalg.rq(a)
    >>> np.allclose(a, r @ q)
    True
    >>> r.shape, q.shape
    ((6, 9), (9, 9))
    >>> r2 = linalg.rq(a, mode='r')
    >>> np.allclose(r, r2)
    True
    >>> r3, q3 = linalg.rq(a, mode='economic')
    >>> r3.shape, q3.shape
    ((6, 6), (6, 9))
",function,"('a', 'overwrite_a', 'lwork', 'mode', 'check_finite')","(nan, False, None, 'full', True)","(nan, 'bool', 'NoneType', 'str', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a, overwrite_a=False, lwork=None, mode='full', check_finite=True)"",)"
scipy,1.1.0,scipy.linalg.rsf2csf,linalg,rsf2csf,"Python Library Documentation: function rsf2csf in module scipy.linalg.decomp_schur

rsf2csf(T, Z, check_finite=True)
    Convert real Schur form to complex Schur form.
    
    Convert a quasi-diagonal real-valued Schur form to the upper triangular
    complex-valued Schur form.
    
    Parameters
    ----------
    T : (M, M) array_like
        Real Schur form of the original array
    Z : (M, M) array_like
        Schur transformation matrix
    check_finite : bool, optional
        Whether to check that the input arrays contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    T : (M, M) ndarray
        Complex Schur form of the original array
    Z : (M, M) ndarray
        Schur transformation matrix corresponding to the complex form
    
    See Also
    --------
    schur : Schur decomposition of an array
    
    Examples
    --------
    >>> from scipy.linalg import schur, rsf2csf
    >>> A = np.array([[0, 2, 2], [0, 1, 2], [1, 0, 1]])
    >>> T, Z = schur(A)
    >>> T
    array([[ 2.65896708,  1.42440458, -1.92933439],
           [ 0.        , -0.32948354, -0.49063704],
           [ 0.        ,  1.31178921, -0.32948354]])
    >>> Z
    array([[0.72711591, -0.60156188, 0.33079564],
           [0.52839428, 0.79801892, 0.28976765],
           [0.43829436, 0.03590414, -0.89811411]])
    >>> T2 , Z2 = rsf2csf(T, Z)
    >>> T2
    array([[2.65896708+0.j, -1.64592781+0.743164187j, -1.21516887+1.00660462j],
           [0.+0.j , -0.32948354+8.02254558e-01j, -0.82115218-2.77555756e-17j],
           [0.+0.j , 0.+0.j, -0.32948354-0.802254558j]])
    >>> Z2
    array([[0.72711591+0.j,  0.28220393-0.31385693j,  0.51319638-0.17258824j],
           [0.52839428+0.j,  0.24720268+0.41635578j, -0.68079517-0.15118243j],
           [0.43829436+0.j, -0.76618703+0.01873251j, -0.03063006+0.46857912j]])
",function,"('(T, Z, check_finite=True)',)",scipy,1.1.0,scipy.linalg.rsf2csf,linalg,rsf2csf,"Python Library Documentation: function rsf2csf in module scipy.linalg.decomp_schur

rsf2csf(T, Z, check_finite=True)
    Convert real Schur form to complex Schur form.
    
    Convert a quasi-diagonal real-valued Schur form to the upper triangular
    complex-valued Schur form.
    
    Parameters
    ----------
    T : (M, M) array_like
        Real Schur form of the original array
    Z : (M, M) array_like
        Schur transformation matrix
    check_finite : bool, optional
        Whether to check that the input arrays contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    T : (M, M) ndarray
        Complex Schur form of the original array
    Z : (M, M) ndarray
        Schur transformation matrix corresponding to the complex form
    
    See Also
    --------
    schur : Schur decomposition of an array
    
    Examples
    --------
    >>> from scipy.linalg import schur, rsf2csf
    >>> A = np.array([[0, 2, 2], [0, 1, 2], [1, 0, 1]])
    >>> T, Z = schur(A)
    >>> T
    array([[ 2.65896708,  1.42440458, -1.92933439],
           [ 0.        , -0.32948354, -0.49063704],
           [ 0.        ,  1.31178921, -0.32948354]])
    >>> Z
    array([[0.72711591, -0.60156188, 0.33079564],
           [0.52839428, 0.79801892, 0.28976765],
           [0.43829436, 0.03590414, -0.89811411]])
    >>> T2 , Z2 = rsf2csf(T, Z)
    >>> T2
    array([[2.65896708+0.j, -1.64592781+0.743164187j, -1.21516887+1.00660462j],
           [0.+0.j , -0.32948354+8.02254558e-01j, -0.82115218-2.77555756e-17j],
           [0.+0.j , 0.+0.j, -0.32948354-0.802254558j]])
    >>> Z2
    array([[0.72711591+0.j,  0.28220393-0.31385693j,  0.51319638-0.17258824j],
           [0.52839428+0.j,  0.24720268+0.41635578j, -0.68079517-0.15118243j],
           [0.43829436+0.j, -0.76618703+0.01873251j, -0.03063006+0.46857912j]])
",function,"('T', 'Z', 'check_finite')","(nan, nan, True)","(nan, nan, 'bool')","('arg_info', 'arg_info', 'arg_info')","('(T, Z, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.schur,linalg,schur,"Python Library Documentation: function schur in module scipy.linalg.decomp_schur

schur(a, output='real', lwork=None, overwrite_a=False, sort=None, check_finite=True)
    Compute Schur decomposition of a matrix.
    
    The Schur decomposition is::
    
        A = Z T Z^H
    
    where Z is unitary and T is either upper-triangular, or for real
    Schur decomposition (output='real'), quasi-upper triangular.  In
    the quasi-triangular form, 2x2 blocks describing complex-valued
    eigenvalue pairs may extrude from the diagonal.
    
    Parameters
    ----------
    a : (M, M) array_like
        Matrix to decompose
    output : {'real', 'complex'}, optional
        Construct the real or complex Schur decomposition (for real matrices).
    lwork : int, optional
        Work array size. If None or -1, it is automatically computed.
    overwrite_a : bool, optional
        Whether to overwrite data in a (may improve performance).
    sort : {None, callable, 'lhp', 'rhp', 'iuc', 'ouc'}, optional
        Specifies whether the upper eigenvalues should be sorted.  A callable
        may be passed that, given a eigenvalue, returns a boolean denoting
        whether the eigenvalue should be sorted to the top-left (True).
        Alternatively, string parameters may be used::
    
            'lhp'   Left-hand plane (x.real < 0.0)
            'rhp'   Right-hand plane (x.real > 0.0)
            'iuc'   Inside the unit circle (x*x.conjugate() <= 1.0)
            'ouc'   Outside the unit circle (x*x.conjugate() > 1.0)
    
        Defaults to None (no sorting).
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    T : (M, M) ndarray
        Schur form of A. It is real-valued for the real Schur decomposition.
    Z : (M, M) ndarray
        An unitary Schur transformation matrix for A.
        It is real-valued for the real Schur decomposition.
    sdim : int
        If and only if sorting was requested, a third return value will
        contain the number of eigenvalues satisfying the sort condition.
    
    Raises
    ------
    LinAlgError
        Error raised under three conditions:
    
        1. The algorithm failed due to a failure of the QR algorithm to
           compute all eigenvalues
        2. If eigenvalue sorting was requested, the eigenvalues could not be
           reordered due to a failure to separate eigenvalues, usually because
           of poor conditioning
        3. If eigenvalue sorting was requested, roundoff errors caused the
           leading eigenvalues to no longer satisfy the sorting condition
    
    See also
    --------
    rsf2csf : Convert real Schur form to complex Schur form
    
    Examples
    --------
    >>> from scipy.linalg import schur, eigvals
    >>> A = np.array([[0, 2, 2], [0, 1, 2], [1, 0, 1]])
    >>> T, Z = schur(A)
    >>> T
    array([[ 2.65896708,  1.42440458, -1.92933439],
           [ 0.        , -0.32948354, -0.49063704],
           [ 0.        ,  1.31178921, -0.32948354]])
    >>> Z
    array([[0.72711591, -0.60156188, 0.33079564],
           [0.52839428, 0.79801892, 0.28976765],
           [0.43829436, 0.03590414, -0.89811411]])
    
    >>> T2, Z2 = schur(A, output='complex')
    >>> T2
    array([[ 2.65896708, -1.22839825+1.32378589j,  0.42590089+1.51937378j],
           [ 0.        , -0.32948354+0.80225456j, -0.59877807+0.56192146j],
           [ 0.        ,  0.                    , -0.32948354-0.80225456j]])
    >>> eigvals(T2)
    array([2.65896708, -0.32948354+0.80225456j, -0.32948354-0.80225456j])
    
    An arbitrary custom eig-sorting condition, having positive imaginary part, 
    which is satisfied by only one eigenvalue
    
    >>> T3, Z3, sdim = schur(A, output='complex', sort=lambda x: x.imag > 0)
    >>> sdim
    1
",function,"(""(a, output='real', lwork=None, overwrite_a=False, sort=None, check_finite=True)"",)",scipy,1.1.0,scipy.linalg.schur,linalg,schur,"Python Library Documentation: function schur in module scipy.linalg.decomp_schur

schur(a, output='real', lwork=None, overwrite_a=False, sort=None, check_finite=True)
    Compute Schur decomposition of a matrix.
    
    The Schur decomposition is::
    
        A = Z T Z^H
    
    where Z is unitary and T is either upper-triangular, or for real
    Schur decomposition (output='real'), quasi-upper triangular.  In
    the quasi-triangular form, 2x2 blocks describing complex-valued
    eigenvalue pairs may extrude from the diagonal.
    
    Parameters
    ----------
    a : (M, M) array_like
        Matrix to decompose
    output : {'real', 'complex'}, optional
        Construct the real or complex Schur decomposition (for real matrices).
    lwork : int, optional
        Work array size. If None or -1, it is automatically computed.
    overwrite_a : bool, optional
        Whether to overwrite data in a (may improve performance).
    sort : {None, callable, 'lhp', 'rhp', 'iuc', 'ouc'}, optional
        Specifies whether the upper eigenvalues should be sorted.  A callable
        may be passed that, given a eigenvalue, returns a boolean denoting
        whether the eigenvalue should be sorted to the top-left (True).
        Alternatively, string parameters may be used::
    
            'lhp'   Left-hand plane (x.real < 0.0)
            'rhp'   Right-hand plane (x.real > 0.0)
            'iuc'   Inside the unit circle (x*x.conjugate() <= 1.0)
            'ouc'   Outside the unit circle (x*x.conjugate() > 1.0)
    
        Defaults to None (no sorting).
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    T : (M, M) ndarray
        Schur form of A. It is real-valued for the real Schur decomposition.
    Z : (M, M) ndarray
        An unitary Schur transformation matrix for A.
        It is real-valued for the real Schur decomposition.
    sdim : int
        If and only if sorting was requested, a third return value will
        contain the number of eigenvalues satisfying the sort condition.
    
    Raises
    ------
    LinAlgError
        Error raised under three conditions:
    
        1. The algorithm failed due to a failure of the QR algorithm to
           compute all eigenvalues
        2. If eigenvalue sorting was requested, the eigenvalues could not be
           reordered due to a failure to separate eigenvalues, usually because
           of poor conditioning
        3. If eigenvalue sorting was requested, roundoff errors caused the
           leading eigenvalues to no longer satisfy the sorting condition
    
    See also
    --------
    rsf2csf : Convert real Schur form to complex Schur form
    
    Examples
    --------
    >>> from scipy.linalg import schur, eigvals
    >>> A = np.array([[0, 2, 2], [0, 1, 2], [1, 0, 1]])
    >>> T, Z = schur(A)
    >>> T
    array([[ 2.65896708,  1.42440458, -1.92933439],
           [ 0.        , -0.32948354, -0.49063704],
           [ 0.        ,  1.31178921, -0.32948354]])
    >>> Z
    array([[0.72711591, -0.60156188, 0.33079564],
           [0.52839428, 0.79801892, 0.28976765],
           [0.43829436, 0.03590414, -0.89811411]])
    
    >>> T2, Z2 = schur(A, output='complex')
    >>> T2
    array([[ 2.65896708, -1.22839825+1.32378589j,  0.42590089+1.51937378j],
           [ 0.        , -0.32948354+0.80225456j, -0.59877807+0.56192146j],
           [ 0.        ,  0.                    , -0.32948354-0.80225456j]])
    >>> eigvals(T2)
    array([2.65896708, -0.32948354+0.80225456j, -0.32948354-0.80225456j])
    
    An arbitrary custom eig-sorting condition, having positive imaginary part, 
    which is satisfied by only one eigenvalue
    
    >>> T3, Z3, sdim = schur(A, output='complex', sort=lambda x: x.imag > 0)
    >>> sdim
    1
",function,"('a', 'output', 'lwork', 'overwrite_a', 'sort', 'check_finite')","(nan, 'real', None, False, None, True)","(nan, 'str', 'NoneType', 'bool', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a, output='real', lwork=None, overwrite_a=False, sort=None, check_finite=True)"",)"
scipy,1.1.0,scipy.linalg.signm,linalg,signm,"Python Library Documentation: function signm in module scipy.linalg.matfuncs

signm(A, disp=True)
    Matrix sign function.
    
    Extension of the scalar sign(x) to matrices.
    
    Parameters
    ----------
    A : (N, N) array_like
        Matrix at which to evaluate the sign function
    disp : bool, optional
        Print warning if error in the result is estimated large
        instead of returning estimated error. (Default: True)
    
    Returns
    -------
    signm : (N, N) ndarray
        Value of the sign function at `A`
    errest : float
        (if disp == False)
    
        1-norm of the estimated error, ||err||_1 / ||A||_1
    
    Examples
    --------
    >>> from scipy.linalg import signm, eigvals
    >>> a = [[1,2,3], [1,2,1], [1,1,1]]
    >>> eigvals(a)
    array([ 4.12488542+0.j, -0.76155718+0.j,  0.63667176+0.j])
    >>> eigvals(signm(a))
    array([-1.+0.j,  1.+0.j,  1.+0.j])
",function,"('(A, disp=True)',)",scipy,1.1.0,scipy.linalg.signm,linalg,signm,"Python Library Documentation: function signm in module scipy.linalg.matfuncs

signm(A, disp=True)
    Matrix sign function.
    
    Extension of the scalar sign(x) to matrices.
    
    Parameters
    ----------
    A : (N, N) array_like
        Matrix at which to evaluate the sign function
    disp : bool, optional
        Print warning if error in the result is estimated large
        instead of returning estimated error. (Default: True)
    
    Returns
    -------
    signm : (N, N) ndarray
        Value of the sign function at `A`
    errest : float
        (if disp == False)
    
        1-norm of the estimated error, ||err||_1 / ||A||_1
    
    Examples
    --------
    >>> from scipy.linalg import signm, eigvals
    >>> a = [[1,2,3], [1,2,1], [1,1,1]]
    >>> eigvals(a)
    array([ 4.12488542+0.j, -0.76155718+0.j,  0.63667176+0.j])
    >>> eigvals(signm(a))
    array([-1.+0.j,  1.+0.j,  1.+0.j])
",function,"('A', 'disp')","(nan, True)","(nan, 'bool')","('arg_info', 'arg_info')","('(A, disp=True)',)"
scipy,1.1.0,scipy.linalg.sinhm,linalg,sinhm,"Python Library Documentation: function sinhm in module scipy.linalg.matfuncs

sinhm(A)
    Compute the hyperbolic matrix sine.
    
    This routine uses expm to compute the matrix exponentials.
    
    Parameters
    ----------
    A : (N, N) array_like
        Input array.
    
    Returns
    -------
    sinhm : (N, N) ndarray
        Hyperbolic matrix sine of `A`
    
    Examples
    --------
    >>> from scipy.linalg import tanhm, sinhm, coshm
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> s = sinhm(a)
    >>> s
    array([[ 10.57300653,  39.28826594],
           [ 13.09608865,  49.86127247]])
    
    Verify tanhm(a) = sinhm(a).dot(inv(coshm(a)))
    
    >>> t = tanhm(a)
    >>> c = coshm(a)
    >>> t - s.dot(np.linalg.inv(c))
    array([[  2.72004641e-15,   4.55191440e-15],
           [  0.00000000e+00,  -5.55111512e-16]])
",function,"('(A)',)",scipy,1.1.0,scipy.linalg.sinhm,linalg,sinhm,"Python Library Documentation: function sinhm in module scipy.linalg.matfuncs

sinhm(A)
    Compute the hyperbolic matrix sine.
    
    This routine uses expm to compute the matrix exponentials.
    
    Parameters
    ----------
    A : (N, N) array_like
        Input array.
    
    Returns
    -------
    sinhm : (N, N) ndarray
        Hyperbolic matrix sine of `A`
    
    Examples
    --------
    >>> from scipy.linalg import tanhm, sinhm, coshm
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> s = sinhm(a)
    >>> s
    array([[ 10.57300653,  39.28826594],
           [ 13.09608865,  49.86127247]])
    
    Verify tanhm(a) = sinhm(a).dot(inv(coshm(a)))
    
    >>> t = tanhm(a)
    >>> c = coshm(a)
    >>> t - s.dot(np.linalg.inv(c))
    array([[  2.72004641e-15,   4.55191440e-15],
           [  0.00000000e+00,  -5.55111512e-16]])
",function,"('A',)","(nan,)","(nan,)","('arg_info',)","('(A)',)"
scipy,1.1.0,scipy.linalg.sinm,linalg,sinm,"Python Library Documentation: function sinm in module scipy.linalg.matfuncs

sinm(A)
    Compute the matrix sine.
    
    This routine uses expm to compute the matrix exponentials.
    
    Parameters
    ----------
    A : (N, N) array_like
        Input array.
    
    Returns
    -------
    sinm : (N, N) ndarray
        Matrix sine of `A`
    
    Examples
    --------
    >>> from scipy.linalg import expm, sinm, cosm
    
    Euler's identity (exp(i*theta) = cos(theta) + i*sin(theta))
    applied to a matrix:
    
    >>> a = np.array([[1.0, 2.0], [-1.0, 3.0]])
    >>> expm(1j*a)
    array([[ 0.42645930+1.89217551j, -2.13721484-0.97811252j],
           [ 1.06860742+0.48905626j, -1.71075555+0.91406299j]])
    >>> cosm(a) + 1j*sinm(a)
    array([[ 0.42645930+1.89217551j, -2.13721484-0.97811252j],
           [ 1.06860742+0.48905626j, -1.71075555+0.91406299j]])
",function,"('(A)',)",scipy,1.1.0,scipy.linalg.sinm,linalg,sinm,"Python Library Documentation: function sinm in module scipy.linalg.matfuncs

sinm(A)
    Compute the matrix sine.
    
    This routine uses expm to compute the matrix exponentials.
    
    Parameters
    ----------
    A : (N, N) array_like
        Input array.
    
    Returns
    -------
    sinm : (N, N) ndarray
        Matrix sine of `A`
    
    Examples
    --------
    >>> from scipy.linalg import expm, sinm, cosm
    
    Euler's identity (exp(i*theta) = cos(theta) + i*sin(theta))
    applied to a matrix:
    
    >>> a = np.array([[1.0, 2.0], [-1.0, 3.0]])
    >>> expm(1j*a)
    array([[ 0.42645930+1.89217551j, -2.13721484-0.97811252j],
           [ 1.06860742+0.48905626j, -1.71075555+0.91406299j]])
    >>> cosm(a) + 1j*sinm(a)
    array([[ 0.42645930+1.89217551j, -2.13721484-0.97811252j],
           [ 1.06860742+0.48905626j, -1.71075555+0.91406299j]])
",function,"('A',)","(nan,)","(nan,)","('arg_info',)","('(A)',)"
scipy,1.1.0,scipy.linalg.solve,linalg,solve,"Python Library Documentation: function solve in module scipy.linalg.basic

solve(a, b, sym_pos=False, lower=False, overwrite_a=False, overwrite_b=False, debug=None, check_finite=True, assume_a='gen', transposed=False)
    Solves the linear equation set ``a * x = b`` for the unknown ``x``
    for square ``a`` matrix.
    
    If the data matrix is known to be a particular type then supplying the
    corresponding string to ``assume_a`` key chooses the dedicated solver.
    The available options are
    
    ===================  ========
     generic matrix       'gen'
     symmetric            'sym'
     hermitian            'her'
     positive definite    'pos'
    ===================  ========
    
    If omitted, ``'gen'`` is the default structure.
    
    The datatype of the arrays define which solver is called regardless
    of the values. In other words, even when the complex array entries have
    precisely zero imaginary parts, the complex solver will be called based
    on the data type of the array.
    
    Parameters
    ----------
    a : (N, N) array_like
        Square input data
    b : (N, NRHS) array_like
        Input data for the right hand side.
    sym_pos : bool, optional
        Assume `a` is symmetric and positive definite. This key is deprecated
        and assume_a = 'pos' keyword is recommended instead. The functionality
        is the same. It will be removed in the future.
    lower : bool, optional
        If True, only the data contained in the lower triangle of `a`. Default
        is to use upper triangle. (ignored for ``'gen'``)
    overwrite_a : bool, optional
        Allow overwriting data in `a` (may enhance performance).
        Default is False.
    overwrite_b : bool, optional
        Allow overwriting data in `b` (may enhance performance).
        Default is False.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    assume_a : str, optional
        Valid entries are explained above.
    transposed: bool, optional
        If True, ``a^T x = b`` for real matrices, raises `NotImplementedError`
        for complex matrices (only for True).
    
    Returns
    -------
    x : (N, NRHS) ndarray
        The solution array.
    
    Raises
    ------
    ValueError
        If size mismatches detected or input a is not square.
    LinAlgError
        If the matrix is singular.
    LinAlgWarning
        If an ill-conditioned input a is detected.
    NotImplementedError
        If transposed is True and input a is a complex matrix.
    
    Examples
    --------
    Given `a` and `b`, solve for `x`:
    
    >>> a = np.array([[3, 2, 0], [1, -1, 0], [0, 5, 1]])
    >>> b = np.array([2, 4, -1])
    >>> from scipy import linalg
    >>> x = linalg.solve(a, b)
    >>> x
    array([ 2., -2.,  9.])
    >>> np.dot(a, x) == b
    array([ True,  True,  True], dtype=bool)
    
    Notes
    -----
    If the input b matrix is a 1D array with N elements, when supplied
    together with an NxN input a, it is assumed as a valid column vector
    despite the apparent size mismatch. This is compatible with the
    numpy.dot() behavior and the returned result is still 1D array.
    
    The generic, symmetric, hermitian and positive definite solutions are
    obtained via calling ?GESV, ?SYSV, ?HESV, and ?POSV routines of
    LAPACK respectively.
",function,"(""(a, b, sym_pos=False, lower=False, overwrite_a=False, overwrite_b=False, debug=None, check_finite=True, assume_a='gen', transposed=False)"",)",scipy,1.1.0,scipy.linalg.solve,linalg,solve,"Python Library Documentation: function solve in module scipy.linalg.basic

solve(a, b, sym_pos=False, lower=False, overwrite_a=False, overwrite_b=False, debug=None, check_finite=True, assume_a='gen', transposed=False)
    Solves the linear equation set ``a * x = b`` for the unknown ``x``
    for square ``a`` matrix.
    
    If the data matrix is known to be a particular type then supplying the
    corresponding string to ``assume_a`` key chooses the dedicated solver.
    The available options are
    
    ===================  ========
     generic matrix       'gen'
     symmetric            'sym'
     hermitian            'her'
     positive definite    'pos'
    ===================  ========
    
    If omitted, ``'gen'`` is the default structure.
    
    The datatype of the arrays define which solver is called regardless
    of the values. In other words, even when the complex array entries have
    precisely zero imaginary parts, the complex solver will be called based
    on the data type of the array.
    
    Parameters
    ----------
    a : (N, N) array_like
        Square input data
    b : (N, NRHS) array_like
        Input data for the right hand side.
    sym_pos : bool, optional
        Assume `a` is symmetric and positive definite. This key is deprecated
        and assume_a = 'pos' keyword is recommended instead. The functionality
        is the same. It will be removed in the future.
    lower : bool, optional
        If True, only the data contained in the lower triangle of `a`. Default
        is to use upper triangle. (ignored for ``'gen'``)
    overwrite_a : bool, optional
        Allow overwriting data in `a` (may enhance performance).
        Default is False.
    overwrite_b : bool, optional
        Allow overwriting data in `b` (may enhance performance).
        Default is False.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    assume_a : str, optional
        Valid entries are explained above.
    transposed: bool, optional
        If True, ``a^T x = b`` for real matrices, raises `NotImplementedError`
        for complex matrices (only for True).
    
    Returns
    -------
    x : (N, NRHS) ndarray
        The solution array.
    
    Raises
    ------
    ValueError
        If size mismatches detected or input a is not square.
    LinAlgError
        If the matrix is singular.
    LinAlgWarning
        If an ill-conditioned input a is detected.
    NotImplementedError
        If transposed is True and input a is a complex matrix.
    
    Examples
    --------
    Given `a` and `b`, solve for `x`:
    
    >>> a = np.array([[3, 2, 0], [1, -1, 0], [0, 5, 1]])
    >>> b = np.array([2, 4, -1])
    >>> from scipy import linalg
    >>> x = linalg.solve(a, b)
    >>> x
    array([ 2., -2.,  9.])
    >>> np.dot(a, x) == b
    array([ True,  True,  True], dtype=bool)
    
    Notes
    -----
    If the input b matrix is a 1D array with N elements, when supplied
    together with an NxN input a, it is assumed as a valid column vector
    despite the apparent size mismatch. This is compatible with the
    numpy.dot() behavior and the returned result is still 1D array.
    
    The generic, symmetric, hermitian and positive definite solutions are
    obtained via calling ?GESV, ?SYSV, ?HESV, and ?POSV routines of
    LAPACK respectively.
",function,"('a', 'b', 'sym_pos', 'lower', 'overwrite_a', 'overwrite_b', 'debug', 'check_finite', 'assume_a', 'transposed')","(nan, nan, False, False, False, False, None, True, 'gen', False)","(nan, nan, 'bool', 'bool', 'bool', 'bool', 'NoneType', 'bool', 'str', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a, b, sym_pos=False, lower=False, overwrite_a=False, overwrite_b=False, debug=None, check_finite=True, assume_a='gen', transposed=False)"",)"
scipy,1.1.0,scipy.linalg.solve_banded,linalg,solve_banded,"Python Library Documentation: function solve_banded in module scipy.linalg.basic

solve_banded(l_and_u, ab, b, overwrite_ab=False, overwrite_b=False, debug=None, check_finite=True)
    Solve the equation a x = b for x, assuming a is banded matrix.
    
    The matrix a is stored in `ab` using the matrix diagonal ordered form::
    
        ab[u + i - j, j] == a[i,j]
    
    Example of `ab` (shape of a is (6,6), `u` =1, `l` =2)::
    
        *    a01  a12  a23  a34  a45
        a00  a11  a22  a33  a44  a55
        a10  a21  a32  a43  a54   *
        a20  a31  a42  a53   *    *
    
    Parameters
    ----------
    (l, u) : (integer, integer)
        Number of non-zero lower and upper diagonals
    ab : (`l` + `u` + 1, M) array_like
        Banded matrix
    b : (M,) or (M, K) array_like
        Right-hand side
    overwrite_ab : bool, optional
        Discard data in `ab` (may enhance performance)
    overwrite_b : bool, optional
        Discard data in `b` (may enhance performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : (M,) or (M, K) ndarray
        The solution to the system a x = b.  Returned shape depends on the
        shape of `b`.
    
    Examples
    --------
    Solve the banded system a x = b, where::
    
            [5  2 -1  0  0]       [0]
            [1  4  2 -1  0]       [1]
        a = [0  1  3  2 -1]   b = [2]
            [0  0  1  2  2]       [2]
            [0  0  0  1  1]       [3]
    
    There is one nonzero diagonal below the main diagonal (l = 1), and
    two above (u = 2).  The diagonal banded form of the matrix is::
    
             [*  * -1 -1 -1]
        ab = [*  2  2  2  2]
             [5  4  3  2  1]
             [1  1  1  1  *]
    
    >>> from scipy.linalg import solve_banded
    >>> ab = np.array([[0,  0, -1, -1, -1],
    ...                [0,  2,  2,  2,  2],
    ...                [5,  4,  3,  2,  1],
    ...                [1,  1,  1,  1,  0]])
    >>> b = np.array([0, 1, 2, 2, 3])
    >>> x = solve_banded((1, 2), ab, b)
    >>> x
    array([-2.37288136,  3.93220339, -4.        ,  4.3559322 , -1.3559322 ])
",function,"('(l_and_u, ab, b, overwrite_ab=False, overwrite_b=False, debug=None, check_finite=True)',)",scipy,1.1.0,scipy.linalg.solve_banded,linalg,solve_banded,"Python Library Documentation: function solve_banded in module scipy.linalg.basic

solve_banded(l_and_u, ab, b, overwrite_ab=False, overwrite_b=False, debug=None, check_finite=True)
    Solve the equation a x = b for x, assuming a is banded matrix.
    
    The matrix a is stored in `ab` using the matrix diagonal ordered form::
    
        ab[u + i - j, j] == a[i,j]
    
    Example of `ab` (shape of a is (6,6), `u` =1, `l` =2)::
    
        *    a01  a12  a23  a34  a45
        a00  a11  a22  a33  a44  a55
        a10  a21  a32  a43  a54   *
        a20  a31  a42  a53   *    *
    
    Parameters
    ----------
    (l, u) : (integer, integer)
        Number of non-zero lower and upper diagonals
    ab : (`l` + `u` + 1, M) array_like
        Banded matrix
    b : (M,) or (M, K) array_like
        Right-hand side
    overwrite_ab : bool, optional
        Discard data in `ab` (may enhance performance)
    overwrite_b : bool, optional
        Discard data in `b` (may enhance performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : (M,) or (M, K) ndarray
        The solution to the system a x = b.  Returned shape depends on the
        shape of `b`.
    
    Examples
    --------
    Solve the banded system a x = b, where::
    
            [5  2 -1  0  0]       [0]
            [1  4  2 -1  0]       [1]
        a = [0  1  3  2 -1]   b = [2]
            [0  0  1  2  2]       [2]
            [0  0  0  1  1]       [3]
    
    There is one nonzero diagonal below the main diagonal (l = 1), and
    two above (u = 2).  The diagonal banded form of the matrix is::
    
             [*  * -1 -1 -1]
        ab = [*  2  2  2  2]
             [5  4  3  2  1]
             [1  1  1  1  *]
    
    >>> from scipy.linalg import solve_banded
    >>> ab = np.array([[0,  0, -1, -1, -1],
    ...                [0,  2,  2,  2,  2],
    ...                [5,  4,  3,  2,  1],
    ...                [1,  1,  1,  1,  0]])
    >>> b = np.array([0, 1, 2, 2, 3])
    >>> x = solve_banded((1, 2), ab, b)
    >>> x
    array([-2.37288136,  3.93220339, -4.        ,  4.3559322 , -1.3559322 ])
",function,"('l_and_u', 'ab', 'b', 'overwrite_ab', 'overwrite_b', 'debug', 'check_finite')","(nan, nan, nan, False, False, None, True)","(nan, nan, nan, 'bool', 'bool', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(l_and_u, ab, b, overwrite_ab=False, overwrite_b=False, debug=None, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.solve_circulant,linalg,solve_circulant,"Python Library Documentation: function solve_circulant in module scipy.linalg.basic

solve_circulant(c, b, singular='raise', tol=None, caxis=-1, baxis=0, outaxis=0)
    Solve C x = b for x, where C is a circulant matrix.
    
    `C` is the circulant matrix associated with the vector `c`.
    
    The system is solved by doing division in Fourier space.  The
    calculation is::
    
        x = ifft(fft(b) / fft(c))
    
    where `fft` and `ifft` are the fast Fourier transform and its inverse,
    respectively.  For a large vector `c`, this is *much* faster than
    solving the system with the full circulant matrix.
    
    Parameters
    ----------
    c : array_like
        The coefficients of the circulant matrix.
    b : array_like
        Right-hand side matrix in ``a x = b``.
    singular : str, optional
        This argument controls how a near singular circulant matrix is
        handled.  If `singular` is ""raise"" and the circulant matrix is
        near singular, a `LinAlgError` is raised.  If `singular` is
        ""lstsq"", the least squares solution is returned.  Default is ""raise"".
    tol : float, optional
        If any eigenvalue of the circulant matrix has an absolute value
        that is less than or equal to `tol`, the matrix is considered to be
        near singular.  If not given, `tol` is set to::
    
            tol = abs_eigs.max() * abs_eigs.size * np.finfo(np.float64).eps
    
        where `abs_eigs` is the array of absolute values of the eigenvalues
        of the circulant matrix.
    caxis : int
        When `c` has dimension greater than 1, it is viewed as a collection
        of circulant vectors.  In this case, `caxis` is the axis of `c` that
        holds the vectors of circulant coefficients.
    baxis : int
        When `b` has dimension greater than 1, it is viewed as a collection
        of vectors.  In this case, `baxis` is the axis of `b` that holds the
        right-hand side vectors.
    outaxis : int
        When `c` or `b` are multidimensional, the value returned by
        `solve_circulant` is multidimensional.  In this case, `outaxis` is
        the axis of the result that holds the solution vectors.
    
    Returns
    -------
    x : ndarray
        Solution to the system ``C x = b``.
    
    Raises
    ------
    LinAlgError
        If the circulant matrix associated with `c` is near singular.
    
    See Also
    --------
    circulant : circulant matrix
    
    Notes
    -----
    For a one-dimensional vector `c` with length `m`, and an array `b`
    with shape ``(m, ...)``,
    
        solve_circulant(c, b)
    
    returns the same result as
    
        solve(circulant(c), b)
    
    where `solve` and `circulant` are from `scipy.linalg`.
    
    .. versionadded:: 0.16.0
    
    Examples
    --------
    >>> from scipy.linalg import solve_circulant, solve, circulant, lstsq
    
    >>> c = np.array([2, 2, 4])
    >>> b = np.array([1, 2, 3])
    >>> solve_circulant(c, b)
    array([ 0.75, -0.25,  0.25])
    
    Compare that result to solving the system with `scipy.linalg.solve`:
    
    >>> solve(circulant(c), b)
    array([ 0.75, -0.25,  0.25])
    
    A singular example:
    
    >>> c = np.array([1, 1, 0, 0])
    >>> b = np.array([1, 2, 3, 4])
    
    Calling ``solve_circulant(c, b)`` will raise a `LinAlgError`.  For the
    least square solution, use the option ``singular='lstsq'``:
    
    >>> solve_circulant(c, b, singular='lstsq')
    array([ 0.25,  1.25,  2.25,  1.25])
    
    Compare to `scipy.linalg.lstsq`:
    
    >>> x, resid, rnk, s = lstsq(circulant(c), b)
    >>> x
    array([ 0.25,  1.25,  2.25,  1.25])
    
    A broadcasting example:
    
    Suppose we have the vectors of two circulant matrices stored in an array
    with shape (2, 5), and three `b` vectors stored in an array with shape
    (3, 5).  For example,
    
    >>> c = np.array([[1.5, 2, 3, 0, 0], [1, 1, 4, 3, 2]])
    >>> b = np.arange(15).reshape(-1, 5)
    
    We want to solve all combinations of circulant matrices and `b` vectors,
    with the result stored in an array with shape (2, 3, 5).  When we
    disregard the axes of `c` and `b` that hold the vectors of coefficients,
    the shapes of the collections are (2,) and (3,), respectively, which are
    not compatible for broadcasting.  To have a broadcast result with shape
    (2, 3), we add a trivial dimension to `c`: ``c[:, np.newaxis, :]`` has
    shape (2, 1, 5).  The last dimension holds the coefficients of the
    circulant matrices, so when we call `solve_circulant`, we can use the
    default ``caxis=-1``.  The coefficients of the `b` vectors are in the last
    dimension of the array `b`, so we use ``baxis=-1``.  If we use the
    default `outaxis`, the result will have shape (5, 2, 3), so we'll use
    ``outaxis=-1`` to put the solution vectors in the last dimension.
    
    >>> x = solve_circulant(c[:, np.newaxis, :], b, baxis=-1, outaxis=-1)
    >>> x.shape
    (2, 3, 5)
    >>> np.set_printoptions(precision=3)  # For compact output of numbers.
    >>> x
    array([[[-0.118,  0.22 ,  1.277, -0.142,  0.302],
            [ 0.651,  0.989,  2.046,  0.627,  1.072],
            [ 1.42 ,  1.758,  2.816,  1.396,  1.841]],
           [[ 0.401,  0.304,  0.694, -0.867,  0.377],
            [ 0.856,  0.758,  1.149, -0.412,  0.831],
            [ 1.31 ,  1.213,  1.603,  0.042,  1.286]]])
    
    Check by solving one pair of `c` and `b` vectors (cf. ``x[1, 1, :]``):
    
    >>> solve_circulant(c[1], b[1, :])
    array([ 0.856,  0.758,  1.149, -0.412,  0.831])
",function,"(""(c, b, singular='raise', tol=None, caxis=-1, baxis=0, outaxis=0)"",)",scipy,1.1.0,scipy.linalg.solve_circulant,linalg,solve_circulant,"Python Library Documentation: function solve_circulant in module scipy.linalg.basic

solve_circulant(c, b, singular='raise', tol=None, caxis=-1, baxis=0, outaxis=0)
    Solve C x = b for x, where C is a circulant matrix.
    
    `C` is the circulant matrix associated with the vector `c`.
    
    The system is solved by doing division in Fourier space.  The
    calculation is::
    
        x = ifft(fft(b) / fft(c))
    
    where `fft` and `ifft` are the fast Fourier transform and its inverse,
    respectively.  For a large vector `c`, this is *much* faster than
    solving the system with the full circulant matrix.
    
    Parameters
    ----------
    c : array_like
        The coefficients of the circulant matrix.
    b : array_like
        Right-hand side matrix in ``a x = b``.
    singular : str, optional
        This argument controls how a near singular circulant matrix is
        handled.  If `singular` is ""raise"" and the circulant matrix is
        near singular, a `LinAlgError` is raised.  If `singular` is
        ""lstsq"", the least squares solution is returned.  Default is ""raise"".
    tol : float, optional
        If any eigenvalue of the circulant matrix has an absolute value
        that is less than or equal to `tol`, the matrix is considered to be
        near singular.  If not given, `tol` is set to::
    
            tol = abs_eigs.max() * abs_eigs.size * np.finfo(np.float64).eps
    
        where `abs_eigs` is the array of absolute values of the eigenvalues
        of the circulant matrix.
    caxis : int
        When `c` has dimension greater than 1, it is viewed as a collection
        of circulant vectors.  In this case, `caxis` is the axis of `c` that
        holds the vectors of circulant coefficients.
    baxis : int
        When `b` has dimension greater than 1, it is viewed as a collection
        of vectors.  In this case, `baxis` is the axis of `b` that holds the
        right-hand side vectors.
    outaxis : int
        When `c` or `b` are multidimensional, the value returned by
        `solve_circulant` is multidimensional.  In this case, `outaxis` is
        the axis of the result that holds the solution vectors.
    
    Returns
    -------
    x : ndarray
        Solution to the system ``C x = b``.
    
    Raises
    ------
    LinAlgError
        If the circulant matrix associated with `c` is near singular.
    
    See Also
    --------
    circulant : circulant matrix
    
    Notes
    -----
    For a one-dimensional vector `c` with length `m`, and an array `b`
    with shape ``(m, ...)``,
    
        solve_circulant(c, b)
    
    returns the same result as
    
        solve(circulant(c), b)
    
    where `solve` and `circulant` are from `scipy.linalg`.
    
    .. versionadded:: 0.16.0
    
    Examples
    --------
    >>> from scipy.linalg import solve_circulant, solve, circulant, lstsq
    
    >>> c = np.array([2, 2, 4])
    >>> b = np.array([1, 2, 3])
    >>> solve_circulant(c, b)
    array([ 0.75, -0.25,  0.25])
    
    Compare that result to solving the system with `scipy.linalg.solve`:
    
    >>> solve(circulant(c), b)
    array([ 0.75, -0.25,  0.25])
    
    A singular example:
    
    >>> c = np.array([1, 1, 0, 0])
    >>> b = np.array([1, 2, 3, 4])
    
    Calling ``solve_circulant(c, b)`` will raise a `LinAlgError`.  For the
    least square solution, use the option ``singular='lstsq'``:
    
    >>> solve_circulant(c, b, singular='lstsq')
    array([ 0.25,  1.25,  2.25,  1.25])
    
    Compare to `scipy.linalg.lstsq`:
    
    >>> x, resid, rnk, s = lstsq(circulant(c), b)
    >>> x
    array([ 0.25,  1.25,  2.25,  1.25])
    
    A broadcasting example:
    
    Suppose we have the vectors of two circulant matrices stored in an array
    with shape (2, 5), and three `b` vectors stored in an array with shape
    (3, 5).  For example,
    
    >>> c = np.array([[1.5, 2, 3, 0, 0], [1, 1, 4, 3, 2]])
    >>> b = np.arange(15).reshape(-1, 5)
    
    We want to solve all combinations of circulant matrices and `b` vectors,
    with the result stored in an array with shape (2, 3, 5).  When we
    disregard the axes of `c` and `b` that hold the vectors of coefficients,
    the shapes of the collections are (2,) and (3,), respectively, which are
    not compatible for broadcasting.  To have a broadcast result with shape
    (2, 3), we add a trivial dimension to `c`: ``c[:, np.newaxis, :]`` has
    shape (2, 1, 5).  The last dimension holds the coefficients of the
    circulant matrices, so when we call `solve_circulant`, we can use the
    default ``caxis=-1``.  The coefficients of the `b` vectors are in the last
    dimension of the array `b`, so we use ``baxis=-1``.  If we use the
    default `outaxis`, the result will have shape (5, 2, 3), so we'll use
    ``outaxis=-1`` to put the solution vectors in the last dimension.
    
    >>> x = solve_circulant(c[:, np.newaxis, :], b, baxis=-1, outaxis=-1)
    >>> x.shape
    (2, 3, 5)
    >>> np.set_printoptions(precision=3)  # For compact output of numbers.
    >>> x
    array([[[-0.118,  0.22 ,  1.277, -0.142,  0.302],
            [ 0.651,  0.989,  2.046,  0.627,  1.072],
            [ 1.42 ,  1.758,  2.816,  1.396,  1.841]],
           [[ 0.401,  0.304,  0.694, -0.867,  0.377],
            [ 0.856,  0.758,  1.149, -0.412,  0.831],
            [ 1.31 ,  1.213,  1.603,  0.042,  1.286]]])
    
    Check by solving one pair of `c` and `b` vectors (cf. ``x[1, 1, :]``):
    
    >>> solve_circulant(c[1], b[1, :])
    array([ 0.856,  0.758,  1.149, -0.412,  0.831])
",function,"('c', 'b', 'singular', 'tol', 'caxis', 'baxis', 'outaxis')","(nan, nan, 'raise', None, -1, 0, 0)","(nan, nan, nan, 'NoneType', 'int', 'int', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(c, b, singular='raise', tol=None, caxis=-1, baxis=0, outaxis=0)"",)"
scipy,1.1.0,scipy.linalg.solve_continuous_are,linalg,solve_continuous_are,"Python Library Documentation: function solve_continuous_are in module scipy.linalg._solvers

solve_continuous_are(a, b, q, r, e=None, s=None, balanced=True)
    Solves the continuous-time algebraic Riccati equation (CARE).
    
    The CARE is defined as
    
    .. math::
    
          X A + A^H X - X B R^{-1} B^H X + Q = 0
    
    The limitations for a solution to exist are :
    
        * All eigenvalues of :math:`A` on the right half plane, should be
          controllable.
    
        * The associated hamiltonian pencil (See Notes), should have
          eigenvalues sufficiently away from the imaginary axis.
    
    Moreover, if ``e`` or ``s`` is not precisely ``None``, then the
    generalized version of CARE
    
    .. math::
    
          E^HXA + A^HXE - (E^HXB + S) R^{-1} (B^HXE + S^H) + Q = 0
    
    is solved. When omitted, ``e`` is assumed to be the identity and ``s``
    is assumed to be the zero matrix with sizes compatible with ``a`` and
    ``b`` respectively.
    
    Parameters
    ----------
    a : (M, M) array_like
        Square matrix
    b : (M, N) array_like
        Input
    q : (M, M) array_like
        Input
    r : (N, N) array_like
        Nonsingular square matrix
    e : (M, M) array_like, optional
        Nonsingular square matrix
    s : (M, N) array_like, optional
        Input
    balanced : bool, optional
        The boolean that indicates whether a balancing step is performed
        on the data. The default is set to True.
    
    Returns
    -------
    x : (M, M) ndarray
        Solution to the continuous-time algebraic Riccati equation.
    
    Raises
    ------
    LinAlgError
        For cases where the stable subspace of the pencil could not be
        isolated. See Notes section and the references for details.
    
    See Also
    --------
    solve_discrete_are : Solves the discrete-time algebraic Riccati equation
    
    Notes
    -----
    The equation is solved by forming the extended hamiltonian matrix pencil,
    as described in [1]_, :math:`H - \lambda J` given by the block matrices ::
    
        [ A    0    B ]             [ E   0    0 ]
        [-Q  -A^H  -S ] - \lambda * [ 0  E^H   0 ]
        [ S^H B^H   R ]             [ 0   0    0 ]
    
    and using a QZ decomposition method.
    
    In this algorithm, the fail conditions are linked to the symmetry
    of the product :math:`U_2 U_1^{-1}` and condition number of
    :math:`U_1`. Here, :math:`U` is the 2m-by-m matrix that holds the
    eigenvectors spanning the stable subspace with 2m rows and partitioned
    into two m-row matrices. See [1]_ and [2]_ for more details.
    
    In order to improve the QZ decomposition accuracy, the pencil goes
    through a balancing step where the sum of absolute values of
    :math:`H` and :math:`J` entries (after removing the diagonal entries of
    the sum) is balanced following the recipe given in [3]_.
    
    .. versionadded:: 0.11.0
    
    References
    ----------
    .. [1]  P. van Dooren , ""A Generalized Eigenvalue Approach For Solving
       Riccati Equations."", SIAM Journal on Scientific and Statistical
       Computing, Vol.2(2), DOI: 10.1137/0902010
    
    .. [2] A.J. Laub, ""A Schur Method for Solving Algebraic Riccati
       Equations."", Massachusetts Institute of Technology. Laboratory for
       Information and Decision Systems. LIDS-R ; 859. Available online :
       http://hdl.handle.net/1721.1/1301
    
    .. [3] P. Benner, ""Symplectic Balancing of Hamiltonian Matrices"", 2001,
       SIAM J. Sci. Comput., 2001, Vol.22(5), DOI: 10.1137/S1064827500367993
    
    Examples
    --------
    Given `a`, `b`, `q`, and `r` solve for `x`:
    
    >>> from scipy import linalg
    >>> a = np.array([[4, 3], [-4.5, -3.5]])
    >>> b = np.array([[1], [-1]])
    >>> q = np.array([[9, 6], [6, 4.]])
    >>> r = 1
    >>> x = linalg.solve_continuous_are(a, b, q, r)
    >>> x
    array([[ 21.72792206,  14.48528137],
           [ 14.48528137,   9.65685425]])
    >>> np.allclose(a.T.dot(x) + x.dot(a)-x.dot(b).dot(b.T).dot(x), -q)
    True
",function,"('(a, b, q, r, e=None, s=None, balanced=True)',)",scipy,1.1.0,scipy.linalg.solve_continuous_are,linalg,solve_continuous_are,"Python Library Documentation: function solve_continuous_are in module scipy.linalg._solvers

solve_continuous_are(a, b, q, r, e=None, s=None, balanced=True)
    Solves the continuous-time algebraic Riccati equation (CARE).
    
    The CARE is defined as
    
    .. math::
    
          X A + A^H X - X B R^{-1} B^H X + Q = 0
    
    The limitations for a solution to exist are :
    
        * All eigenvalues of :math:`A` on the right half plane, should be
          controllable.
    
        * The associated hamiltonian pencil (See Notes), should have
          eigenvalues sufficiently away from the imaginary axis.
    
    Moreover, if ``e`` or ``s`` is not precisely ``None``, then the
    generalized version of CARE
    
    .. math::
    
          E^HXA + A^HXE - (E^HXB + S) R^{-1} (B^HXE + S^H) + Q = 0
    
    is solved. When omitted, ``e`` is assumed to be the identity and ``s``
    is assumed to be the zero matrix with sizes compatible with ``a`` and
    ``b`` respectively.
    
    Parameters
    ----------
    a : (M, M) array_like
        Square matrix
    b : (M, N) array_like
        Input
    q : (M, M) array_like
        Input
    r : (N, N) array_like
        Nonsingular square matrix
    e : (M, M) array_like, optional
        Nonsingular square matrix
    s : (M, N) array_like, optional
        Input
    balanced : bool, optional
        The boolean that indicates whether a balancing step is performed
        on the data. The default is set to True.
    
    Returns
    -------
    x : (M, M) ndarray
        Solution to the continuous-time algebraic Riccati equation.
    
    Raises
    ------
    LinAlgError
        For cases where the stable subspace of the pencil could not be
        isolated. See Notes section and the references for details.
    
    See Also
    --------
    solve_discrete_are : Solves the discrete-time algebraic Riccati equation
    
    Notes
    -----
    The equation is solved by forming the extended hamiltonian matrix pencil,
    as described in [1]_, :math:`H - \lambda J` given by the block matrices ::
    
        [ A    0    B ]             [ E   0    0 ]
        [-Q  -A^H  -S ] - \lambda * [ 0  E^H   0 ]
        [ S^H B^H   R ]             [ 0   0    0 ]
    
    and using a QZ decomposition method.
    
    In this algorithm, the fail conditions are linked to the symmetry
    of the product :math:`U_2 U_1^{-1}` and condition number of
    :math:`U_1`. Here, :math:`U` is the 2m-by-m matrix that holds the
    eigenvectors spanning the stable subspace with 2m rows and partitioned
    into two m-row matrices. See [1]_ and [2]_ for more details.
    
    In order to improve the QZ decomposition accuracy, the pencil goes
    through a balancing step where the sum of absolute values of
    :math:`H` and :math:`J` entries (after removing the diagonal entries of
    the sum) is balanced following the recipe given in [3]_.
    
    .. versionadded:: 0.11.0
    
    References
    ----------
    .. [1]  P. van Dooren , ""A Generalized Eigenvalue Approach For Solving
       Riccati Equations."", SIAM Journal on Scientific and Statistical
       Computing, Vol.2(2), DOI: 10.1137/0902010
    
    .. [2] A.J. Laub, ""A Schur Method for Solving Algebraic Riccati
       Equations."", Massachusetts Institute of Technology. Laboratory for
       Information and Decision Systems. LIDS-R ; 859. Available online :
       http://hdl.handle.net/1721.1/1301
    
    .. [3] P. Benner, ""Symplectic Balancing of Hamiltonian Matrices"", 2001,
       SIAM J. Sci. Comput., 2001, Vol.22(5), DOI: 10.1137/S1064827500367993
    
    Examples
    --------
    Given `a`, `b`, `q`, and `r` solve for `x`:
    
    >>> from scipy import linalg
    >>> a = np.array([[4, 3], [-4.5, -3.5]])
    >>> b = np.array([[1], [-1]])
    >>> q = np.array([[9, 6], [6, 4.]])
    >>> r = 1
    >>> x = linalg.solve_continuous_are(a, b, q, r)
    >>> x
    array([[ 21.72792206,  14.48528137],
           [ 14.48528137,   9.65685425]])
    >>> np.allclose(a.T.dot(x) + x.dot(a)-x.dot(b).dot(b.T).dot(x), -q)
    True
",function,"('a', 'b', 'q', 'r', 'e', 's', 'balanced')","(nan, nan, nan, nan, None, None, True)","(nan, nan, nan, nan, 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, b, q, r, e=None, s=None, balanced=True)',)"
scipy,1.1.0,scipy.linalg.solve_continuous_lyapunov,linalg,solve_continuous_lyapunov,"Python Library Documentation: function solve_continuous_lyapunov in module scipy.linalg._solvers

solve_continuous_lyapunov(a, q)
    Solves the continuous Lyapunov equation :math:`AX + XA^H = Q`.
    
    Uses the Bartels-Stewart algorithm to find :math:`X`.
    
    Parameters
    ----------
    a : array_like
        A square matrix
    
    q : array_like
        Right-hand side square matrix
    
    Returns
    -------
    x : ndarray
        Solution to the continuous Lyapunov equation
    
    See Also
    --------
    solve_discrete_lyapunov : computes the solution to the discrete-time
        Lyapunov equation
    solve_sylvester : computes the solution to the Sylvester equation
    
    Notes
    -----
    The continuous Lyapunov equation is a special form of the Sylvester
    equation, hence this solver relies on LAPACK routine ?TRSYL.
    
    .. versionadded:: 0.11.0
    
    Examples
    --------
    Given `a` and `q` solve for `x`:
    
    >>> from scipy import linalg
    >>> a = np.array([[-3, -2, 0], [-1, -1, 0], [0, -5, -1]])
    >>> b = np.array([2, 4, -1])
    >>> q = np.eye(3)
    >>> x = linalg.solve_continuous_lyapunov(a, q)
    >>> x
    array([[ -0.75  ,   0.875 ,  -3.75  ],
           [  0.875 ,  -1.375 ,   5.3125],
           [ -3.75  ,   5.3125, -27.0625]])
    >>> np.allclose(a.dot(x) + x.dot(a.T), q)
    True
",function,"('(a, q)',)",scipy,1.1.0,scipy.linalg.solve_continuous_lyapunov,linalg,solve_continuous_lyapunov,"Python Library Documentation: function solve_continuous_lyapunov in module scipy.linalg._solvers

solve_continuous_lyapunov(a, q)
    Solves the continuous Lyapunov equation :math:`AX + XA^H = Q`.
    
    Uses the Bartels-Stewart algorithm to find :math:`X`.
    
    Parameters
    ----------
    a : array_like
        A square matrix
    
    q : array_like
        Right-hand side square matrix
    
    Returns
    -------
    x : ndarray
        Solution to the continuous Lyapunov equation
    
    See Also
    --------
    solve_discrete_lyapunov : computes the solution to the discrete-time
        Lyapunov equation
    solve_sylvester : computes the solution to the Sylvester equation
    
    Notes
    -----
    The continuous Lyapunov equation is a special form of the Sylvester
    equation, hence this solver relies on LAPACK routine ?TRSYL.
    
    .. versionadded:: 0.11.0
    
    Examples
    --------
    Given `a` and `q` solve for `x`:
    
    >>> from scipy import linalg
    >>> a = np.array([[-3, -2, 0], [-1, -1, 0], [0, -5, -1]])
    >>> b = np.array([2, 4, -1])
    >>> q = np.eye(3)
    >>> x = linalg.solve_continuous_lyapunov(a, q)
    >>> x
    array([[ -0.75  ,   0.875 ,  -3.75  ],
           [  0.875 ,  -1.375 ,   5.3125],
           [ -3.75  ,   5.3125, -27.0625]])
    >>> np.allclose(a.dot(x) + x.dot(a.T), q)
    True
",function,"('a', 'q')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(a, q)',)"
scipy,1.1.0,scipy.linalg.solve_discrete_are,linalg,solve_discrete_are,"Python Library Documentation: function solve_discrete_are in module scipy.linalg._solvers

solve_discrete_are(a, b, q, r, e=None, s=None, balanced=True)
    Solves the discrete-time algebraic Riccati equation (DARE).
    
    The DARE is defined as
    
    .. math::
    
          A^HXA - X - (A^HXB) (R + B^HXB)^{-1} (B^HXA) + Q = 0
    
    The limitations for a solution to exist are :
    
        * All eigenvalues of :math:`A` outside the unit disc, should be
          controllable.
    
        * The associated symplectic pencil (See Notes), should have
          eigenvalues sufficiently away from the unit circle.
    
    Moreover, if ``e`` and ``s`` are not both precisely ``None``, then the
    generalized version of DARE
    
    .. math::
    
          A^HXA - E^HXE - (A^HXB+S) (R+B^HXB)^{-1} (B^HXA+S^H) + Q = 0
    
    is solved. When omitted, ``e`` is assumed to be the identity and ``s``
    is assumed to be the zero matrix.
    
    Parameters
    ----------
    a : (M, M) array_like
        Square matrix
    b : (M, N) array_like
        Input
    q : (M, M) array_like
        Input
    r : (N, N) array_like
        Square matrix
    e : (M, M) array_like, optional
        Nonsingular square matrix
    s : (M, N) array_like, optional
        Input
    balanced : bool
        The boolean that indicates whether a balancing step is performed
        on the data. The default is set to True.
    
    Returns
    -------
    x : (M, M) ndarray
        Solution to the discrete algebraic Riccati equation.
    
    Raises
    ------
    LinAlgError
        For cases where the stable subspace of the pencil could not be
        isolated. See Notes section and the references for details.
    
    See Also
    --------
    solve_continuous_are : Solves the continuous algebraic Riccati equation
    
    Notes
    -----
    The equation is solved by forming the extended symplectic matrix pencil,
    as described in [1]_, :math:`H - \lambda J` given by the block matrices ::
    
           [  A   0   B ]             [ E   0   B ]
           [ -Q  E^H -S ] - \lambda * [ 0  A^H  0 ]
           [ S^H  0   R ]             [ 0 -B^H  0 ]
    
    and using a QZ decomposition method.
    
    In this algorithm, the fail conditions are linked to the symmetry
    of the product :math:`U_2 U_1^{-1}` and condition number of
    :math:`U_1`. Here, :math:`U` is the 2m-by-m matrix that holds the
    eigenvectors spanning the stable subspace with 2m rows and partitioned
    into two m-row matrices. See [1]_ and [2]_ for more details.
    
    In order to improve the QZ decomposition accuracy, the pencil goes
    through a balancing step where the sum of absolute values of
    :math:`H` and :math:`J` rows/cols (after removing the diagonal entries)
    is balanced following the recipe given in [3]_. If the data has small
    numerical noise, balancing may amplify their effects and some clean up
    is required.
    
    .. versionadded:: 0.11.0
    
    References
    ----------
    .. [1]  P. van Dooren , ""A Generalized Eigenvalue Approach For Solving
       Riccati Equations."", SIAM Journal on Scientific and Statistical
       Computing, Vol.2(2), DOI: 10.1137/0902010
    
    .. [2] A.J. Laub, ""A Schur Method for Solving Algebraic Riccati
       Equations."", Massachusetts Institute of Technology. Laboratory for
       Information and Decision Systems. LIDS-R ; 859. Available online :
       http://hdl.handle.net/1721.1/1301
    
    .. [3] P. Benner, ""Symplectic Balancing of Hamiltonian Matrices"", 2001,
       SIAM J. Sci. Comput., 2001, Vol.22(5), DOI: 10.1137/S1064827500367993
    
    Examples
    --------
    Given `a`, `b`, `q`, and `r` solve for `x`:
    
    >>> from scipy import linalg as la
    >>> a = np.array([[0, 1], [0, -1]])
    >>> b = np.array([[1, 0], [2, 1]])
    >>> q = np.array([[-4, -4], [-4, 7]])
    >>> r = np.array([[9, 3], [3, 1]])
    >>> x = la.solve_discrete_are(a, b, q, r)
    >>> x
    array([[-4., -4.],
           [-4.,  7.]])
    >>> R = la.solve(r + b.T.dot(x).dot(b), b.T.dot(x).dot(a))
    >>> np.allclose(a.T.dot(x).dot(a) - x - a.T.dot(x).dot(b).dot(R), -q)
    True
",function,"('(a, b, q, r, e=None, s=None, balanced=True)',)",scipy,1.1.0,scipy.linalg.solve_discrete_are,linalg,solve_discrete_are,"Python Library Documentation: function solve_discrete_are in module scipy.linalg._solvers

solve_discrete_are(a, b, q, r, e=None, s=None, balanced=True)
    Solves the discrete-time algebraic Riccati equation (DARE).
    
    The DARE is defined as
    
    .. math::
    
          A^HXA - X - (A^HXB) (R + B^HXB)^{-1} (B^HXA) + Q = 0
    
    The limitations for a solution to exist are :
    
        * All eigenvalues of :math:`A` outside the unit disc, should be
          controllable.
    
        * The associated symplectic pencil (See Notes), should have
          eigenvalues sufficiently away from the unit circle.
    
    Moreover, if ``e`` and ``s`` are not both precisely ``None``, then the
    generalized version of DARE
    
    .. math::
    
          A^HXA - E^HXE - (A^HXB+S) (R+B^HXB)^{-1} (B^HXA+S^H) + Q = 0
    
    is solved. When omitted, ``e`` is assumed to be the identity and ``s``
    is assumed to be the zero matrix.
    
    Parameters
    ----------
    a : (M, M) array_like
        Square matrix
    b : (M, N) array_like
        Input
    q : (M, M) array_like
        Input
    r : (N, N) array_like
        Square matrix
    e : (M, M) array_like, optional
        Nonsingular square matrix
    s : (M, N) array_like, optional
        Input
    balanced : bool
        The boolean that indicates whether a balancing step is performed
        on the data. The default is set to True.
    
    Returns
    -------
    x : (M, M) ndarray
        Solution to the discrete algebraic Riccati equation.
    
    Raises
    ------
    LinAlgError
        For cases where the stable subspace of the pencil could not be
        isolated. See Notes section and the references for details.
    
    See Also
    --------
    solve_continuous_are : Solves the continuous algebraic Riccati equation
    
    Notes
    -----
    The equation is solved by forming the extended symplectic matrix pencil,
    as described in [1]_, :math:`H - \lambda J` given by the block matrices ::
    
           [  A   0   B ]             [ E   0   B ]
           [ -Q  E^H -S ] - \lambda * [ 0  A^H  0 ]
           [ S^H  0   R ]             [ 0 -B^H  0 ]
    
    and using a QZ decomposition method.
    
    In this algorithm, the fail conditions are linked to the symmetry
    of the product :math:`U_2 U_1^{-1}` and condition number of
    :math:`U_1`. Here, :math:`U` is the 2m-by-m matrix that holds the
    eigenvectors spanning the stable subspace with 2m rows and partitioned
    into two m-row matrices. See [1]_ and [2]_ for more details.
    
    In order to improve the QZ decomposition accuracy, the pencil goes
    through a balancing step where the sum of absolute values of
    :math:`H` and :math:`J` rows/cols (after removing the diagonal entries)
    is balanced following the recipe given in [3]_. If the data has small
    numerical noise, balancing may amplify their effects and some clean up
    is required.
    
    .. versionadded:: 0.11.0
    
    References
    ----------
    .. [1]  P. van Dooren , ""A Generalized Eigenvalue Approach For Solving
       Riccati Equations."", SIAM Journal on Scientific and Statistical
       Computing, Vol.2(2), DOI: 10.1137/0902010
    
    .. [2] A.J. Laub, ""A Schur Method for Solving Algebraic Riccati
       Equations."", Massachusetts Institute of Technology. Laboratory for
       Information and Decision Systems. LIDS-R ; 859. Available online :
       http://hdl.handle.net/1721.1/1301
    
    .. [3] P. Benner, ""Symplectic Balancing of Hamiltonian Matrices"", 2001,
       SIAM J. Sci. Comput., 2001, Vol.22(5), DOI: 10.1137/S1064827500367993
    
    Examples
    --------
    Given `a`, `b`, `q`, and `r` solve for `x`:
    
    >>> from scipy import linalg as la
    >>> a = np.array([[0, 1], [0, -1]])
    >>> b = np.array([[1, 0], [2, 1]])
    >>> q = np.array([[-4, -4], [-4, 7]])
    >>> r = np.array([[9, 3], [3, 1]])
    >>> x = la.solve_discrete_are(a, b, q, r)
    >>> x
    array([[-4., -4.],
           [-4.,  7.]])
    >>> R = la.solve(r + b.T.dot(x).dot(b), b.T.dot(x).dot(a))
    >>> np.allclose(a.T.dot(x).dot(a) - x - a.T.dot(x).dot(b).dot(R), -q)
    True
",function,"('a', 'b', 'q', 'r', 'e', 's', 'balanced')","(nan, nan, nan, nan, None, None, True)","(nan, nan, nan, nan, 'NoneType', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, b, q, r, e=None, s=None, balanced=True)',)"
scipy,1.1.0,scipy.linalg.solve_discrete_lyapunov,linalg,solve_discrete_lyapunov,"Python Library Documentation: function solve_discrete_lyapunov in module scipy.linalg._solvers

solve_discrete_lyapunov(a, q, method=None)
    Solves the discrete Lyapunov equation :math:`AXA^H - X + Q = 0`.
    
    Parameters
    ----------
    a, q : (M, M) array_like
        Square matrices corresponding to A and Q in the equation
        above respectively. Must have the same shape.
    
    method : {'direct', 'bilinear'}, optional
        Type of solver.
    
        If not given, chosen to be ``direct`` if ``M`` is less than 10 and
        ``bilinear`` otherwise.
    
    Returns
    -------
    x : ndarray
        Solution to the discrete Lyapunov equation
    
    See Also
    --------
    solve_continuous_lyapunov : computes the solution to the continuous-time
        Lyapunov equation
    
    Notes
    -----
    This section describes the available solvers that can be selected by the
    'method' parameter. The default method is *direct* if ``M`` is less than 10
    and ``bilinear`` otherwise.
    
    Method *direct* uses a direct analytical solution to the discrete Lyapunov
    equation. The algorithm is given in, for example, [1]_. However it requires
    the linear solution of a system with dimension :math:`M^2` so that
    performance degrades rapidly for even moderately sized matrices.
    
    Method *bilinear* uses a bilinear transformation to convert the discrete
    Lyapunov equation to a continuous Lyapunov equation :math:`(BX+XB'=-C)`
    where :math:`B=(A-I)(A+I)^{-1}` and
    :math:`C=2(A' + I)^{-1} Q (A + I)^{-1}`. The continuous equation can be
    efficiently solved since it is a special case of a Sylvester equation.
    The transformation algorithm is from Popov (1964) as described in [2]_.
    
    .. versionadded:: 0.11.0
    
    References
    ----------
    .. [1] Hamilton, James D. Time Series Analysis, Princeton: Princeton
       University Press, 1994.  265.  Print.
       http://doc1.lbfl.li/aca/FLMF037168.pdf
    .. [2] Gajic, Z., and M.T.J. Qureshi. 2008.
       Lyapunov Matrix Equation in System Stability and Control.
       Dover Books on Engineering Series. Dover Publications.
    
    Examples
    --------
    Given `a` and `q` solve for `x`:
    
    >>> from scipy import linalg
    >>> a = np.array([[0.2, 0.5],[0.7, -0.9]])
    >>> q = np.eye(2)
    >>> x = linalg.solve_discrete_lyapunov(a, q)
    >>> x
    array([[ 0.70872893,  1.43518822],
           [ 1.43518822, -2.4266315 ]])
    >>> np.allclose(a.dot(x).dot(a.T)-x, -q)
    True
",function,"('(a, q, method=None)',)",scipy,1.1.0,scipy.linalg.solve_discrete_lyapunov,linalg,solve_discrete_lyapunov,"Python Library Documentation: function solve_discrete_lyapunov in module scipy.linalg._solvers

solve_discrete_lyapunov(a, q, method=None)
    Solves the discrete Lyapunov equation :math:`AXA^H - X + Q = 0`.
    
    Parameters
    ----------
    a, q : (M, M) array_like
        Square matrices corresponding to A and Q in the equation
        above respectively. Must have the same shape.
    
    method : {'direct', 'bilinear'}, optional
        Type of solver.
    
        If not given, chosen to be ``direct`` if ``M`` is less than 10 and
        ``bilinear`` otherwise.
    
    Returns
    -------
    x : ndarray
        Solution to the discrete Lyapunov equation
    
    See Also
    --------
    solve_continuous_lyapunov : computes the solution to the continuous-time
        Lyapunov equation
    
    Notes
    -----
    This section describes the available solvers that can be selected by the
    'method' parameter. The default method is *direct* if ``M`` is less than 10
    and ``bilinear`` otherwise.
    
    Method *direct* uses a direct analytical solution to the discrete Lyapunov
    equation. The algorithm is given in, for example, [1]_. However it requires
    the linear solution of a system with dimension :math:`M^2` so that
    performance degrades rapidly for even moderately sized matrices.
    
    Method *bilinear* uses a bilinear transformation to convert the discrete
    Lyapunov equation to a continuous Lyapunov equation :math:`(BX+XB'=-C)`
    where :math:`B=(A-I)(A+I)^{-1}` and
    :math:`C=2(A' + I)^{-1} Q (A + I)^{-1}`. The continuous equation can be
    efficiently solved since it is a special case of a Sylvester equation.
    The transformation algorithm is from Popov (1964) as described in [2]_.
    
    .. versionadded:: 0.11.0
    
    References
    ----------
    .. [1] Hamilton, James D. Time Series Analysis, Princeton: Princeton
       University Press, 1994.  265.  Print.
       http://doc1.lbfl.li/aca/FLMF037168.pdf
    .. [2] Gajic, Z., and M.T.J. Qureshi. 2008.
       Lyapunov Matrix Equation in System Stability and Control.
       Dover Books on Engineering Series. Dover Publications.
    
    Examples
    --------
    Given `a` and `q` solve for `x`:
    
    >>> from scipy import linalg
    >>> a = np.array([[0.2, 0.5],[0.7, -0.9]])
    >>> q = np.eye(2)
    >>> x = linalg.solve_discrete_lyapunov(a, q)
    >>> x
    array([[ 0.70872893,  1.43518822],
           [ 1.43518822, -2.4266315 ]])
    >>> np.allclose(a.dot(x).dot(a.T)-x, -q)
    True
",function,"('a', 'q', 'method')","(nan, nan, None)","(nan, nan, 'NoneType')","('arg_info', 'arg_info', 'arg_info')","('(a, q, method=None)',)"
scipy,1.1.0,scipy.linalg.solve_lyapunov,linalg,solve_continuous_lyapunov,"Python Library Documentation: function solve_continuous_lyapunov in module scipy.linalg._solvers

solve_continuous_lyapunov(a, q)
    Solves the continuous Lyapunov equation :math:`AX + XA^H = Q`.
    
    Uses the Bartels-Stewart algorithm to find :math:`X`.
    
    Parameters
    ----------
    a : array_like
        A square matrix
    
    q : array_like
        Right-hand side square matrix
    
    Returns
    -------
    x : ndarray
        Solution to the continuous Lyapunov equation
    
    See Also
    --------
    solve_discrete_lyapunov : computes the solution to the discrete-time
        Lyapunov equation
    solve_sylvester : computes the solution to the Sylvester equation
    
    Notes
    -----
    The continuous Lyapunov equation is a special form of the Sylvester
    equation, hence this solver relies on LAPACK routine ?TRSYL.
    
    .. versionadded:: 0.11.0
    
    Examples
    --------
    Given `a` and `q` solve for `x`:
    
    >>> from scipy import linalg
    >>> a = np.array([[-3, -2, 0], [-1, -1, 0], [0, -5, -1]])
    >>> b = np.array([2, 4, -1])
    >>> q = np.eye(3)
    >>> x = linalg.solve_continuous_lyapunov(a, q)
    >>> x
    array([[ -0.75  ,   0.875 ,  -3.75  ],
           [  0.875 ,  -1.375 ,   5.3125],
           [ -3.75  ,   5.3125, -27.0625]])
    >>> np.allclose(a.dot(x) + x.dot(a.T), q)
    True
",function,"('(a, q)',)",scipy,1.1.0,scipy.linalg.solve_lyapunov,linalg,solve_continuous_lyapunov,"Python Library Documentation: function solve_continuous_lyapunov in module scipy.linalg._solvers

solve_continuous_lyapunov(a, q)
    Solves the continuous Lyapunov equation :math:`AX + XA^H = Q`.
    
    Uses the Bartels-Stewart algorithm to find :math:`X`.
    
    Parameters
    ----------
    a : array_like
        A square matrix
    
    q : array_like
        Right-hand side square matrix
    
    Returns
    -------
    x : ndarray
        Solution to the continuous Lyapunov equation
    
    See Also
    --------
    solve_discrete_lyapunov : computes the solution to the discrete-time
        Lyapunov equation
    solve_sylvester : computes the solution to the Sylvester equation
    
    Notes
    -----
    The continuous Lyapunov equation is a special form of the Sylvester
    equation, hence this solver relies on LAPACK routine ?TRSYL.
    
    .. versionadded:: 0.11.0
    
    Examples
    --------
    Given `a` and `q` solve for `x`:
    
    >>> from scipy import linalg
    >>> a = np.array([[-3, -2, 0], [-1, -1, 0], [0, -5, -1]])
    >>> b = np.array([2, 4, -1])
    >>> q = np.eye(3)
    >>> x = linalg.solve_continuous_lyapunov(a, q)
    >>> x
    array([[ -0.75  ,   0.875 ,  -3.75  ],
           [  0.875 ,  -1.375 ,   5.3125],
           [ -3.75  ,   5.3125, -27.0625]])
    >>> np.allclose(a.dot(x) + x.dot(a.T), q)
    True
",function,"('a', 'q')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(a, q)',)"
scipy,1.1.0,scipy.linalg.solve_sylvester,linalg,solve_sylvester,"Python Library Documentation: function solve_sylvester in module scipy.linalg._solvers

solve_sylvester(a, b, q)
    Computes a solution (X) to the Sylvester equation :math:`AX + XB = Q`.
    
    Parameters
    ----------
    a : (M, M) array_like
        Leading matrix of the Sylvester equation
    b : (N, N) array_like
        Trailing matrix of the Sylvester equation
    q : (M, N) array_like
        Right-hand side
    
    Returns
    -------
    x : (M, N) ndarray
        The solution to the Sylvester equation.
    
    Raises
    ------
    LinAlgError
        If solution was not found
    
    Notes
    -----
    Computes a solution to the Sylvester matrix equation via the Bartels-
    Stewart algorithm.  The A and B matrices first undergo Schur
    decompositions.  The resulting matrices are used to construct an
    alternative Sylvester equation (``RY + YS^T = F``) where the R and S
    matrices are in quasi-triangular form (or, when R, S or F are complex,
    triangular form).  The simplified equation is then solved using
    ``*TRSYL`` from LAPACK directly.
    
    .. versionadded:: 0.11.0
    
    Examples
    --------
    Given `a`, `b`, and `q` solve for `x`:
    
    >>> from scipy import linalg
    >>> a = np.array([[-3, -2, 0], [-1, -1, 3], [3, -5, -1]])
    >>> b = np.array([[1]])
    >>> q = np.array([[1],[2],[3]])
    >>> x = linalg.solve_sylvester(a, b, q)
    >>> x
    array([[ 0.0625],
           [-0.5625],
           [ 0.6875]])
    >>> np.allclose(a.dot(x) + x.dot(b), q)
    True
",function,"('(a, b, q)',)",scipy,1.1.0,scipy.linalg.solve_sylvester,linalg,solve_sylvester,"Python Library Documentation: function solve_sylvester in module scipy.linalg._solvers

solve_sylvester(a, b, q)
    Computes a solution (X) to the Sylvester equation :math:`AX + XB = Q`.
    
    Parameters
    ----------
    a : (M, M) array_like
        Leading matrix of the Sylvester equation
    b : (N, N) array_like
        Trailing matrix of the Sylvester equation
    q : (M, N) array_like
        Right-hand side
    
    Returns
    -------
    x : (M, N) ndarray
        The solution to the Sylvester equation.
    
    Raises
    ------
    LinAlgError
        If solution was not found
    
    Notes
    -----
    Computes a solution to the Sylvester matrix equation via the Bartels-
    Stewart algorithm.  The A and B matrices first undergo Schur
    decompositions.  The resulting matrices are used to construct an
    alternative Sylvester equation (``RY + YS^T = F``) where the R and S
    matrices are in quasi-triangular form (or, when R, S or F are complex,
    triangular form).  The simplified equation is then solved using
    ``*TRSYL`` from LAPACK directly.
    
    .. versionadded:: 0.11.0
    
    Examples
    --------
    Given `a`, `b`, and `q` solve for `x`:
    
    >>> from scipy import linalg
    >>> a = np.array([[-3, -2, 0], [-1, -1, 3], [3, -5, -1]])
    >>> b = np.array([[1]])
    >>> q = np.array([[1],[2],[3]])
    >>> x = linalg.solve_sylvester(a, b, q)
    >>> x
    array([[ 0.0625],
           [-0.5625],
           [ 0.6875]])
    >>> np.allclose(a.dot(x) + x.dot(b), q)
    True
",function,"('a', 'b', 'q')","(nan, nan, nan)","(nan, nan, nan)","('arg_info', 'arg_info', 'arg_info')","('(a, b, q)',)"
scipy,1.1.0,scipy.linalg.solve_toeplitz,linalg,solve_toeplitz,"Python Library Documentation: function solve_toeplitz in module scipy.linalg.basic

solve_toeplitz(c_or_cr, b, check_finite=True)
    Solve a Toeplitz system using Levinson Recursion
    
    The Toeplitz matrix has constant diagonals, with c as its first column
    and r as its first row.  If r is not given, ``r == conjugate(c)`` is
    assumed.
    
    Parameters
    ----------
    c_or_cr : array_like or tuple of (array_like, array_like)
        The vector ``c``, or a tuple of arrays (``c``, ``r``). Whatever the
        actual shape of ``c``, it will be converted to a 1-D array. If not
        supplied, ``r = conjugate(c)`` is assumed; in this case, if c[0] is
        real, the Toeplitz matrix is Hermitian. r[0] is ignored; the first row
        of the Toeplitz matrix is ``[c[0], r[1:]]``.  Whatever the actual shape
        of ``r``, it will be converted to a 1-D array.
    b : (M,) or (M, K) array_like
        Right-hand side in ``T x = b``.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (result entirely NaNs) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : (M,) or (M, K) ndarray
        The solution to the system ``T x = b``.  Shape of return matches shape
        of `b`.
    
    See Also
    --------
    toeplitz : Toeplitz matrix
    
    Notes
    -----
    The solution is computed using Levinson-Durbin recursion, which is faster
    than generic least-squares methods, but can be less numerically stable.
    
    Examples
    --------
    Solve the Toeplitz system T x = b, where::
    
            [ 1 -1 -2 -3]       [1]
        T = [ 3  1 -1 -2]   b = [2]
            [ 6  3  1 -1]       [2]
            [10  6  3  1]       [5]
    
    To specify the Toeplitz matrix, only the first column and the first
    row are needed.
    
    >>> c = np.array([1, 3, 6, 10])    # First column of T
    >>> r = np.array([1, -1, -2, -3])  # First row of T
    >>> b = np.array([1, 2, 2, 5])
    
    >>> from scipy.linalg import solve_toeplitz, toeplitz
    >>> x = solve_toeplitz((c, r), b)
    >>> x
    array([ 1.66666667, -1.        , -2.66666667,  2.33333333])
    
    Check the result by creating the full Toeplitz matrix and
    multiplying it by `x`.  We should get `b`.
    
    >>> T = toeplitz(c, r)
    >>> T.dot(x)
    array([ 1.,  2.,  2.,  5.])
",function,"('(c_or_cr, b, check_finite=True)',)",scipy,1.1.0,scipy.linalg.solve_toeplitz,linalg,solve_toeplitz,"Python Library Documentation: function solve_toeplitz in module scipy.linalg.basic

solve_toeplitz(c_or_cr, b, check_finite=True)
    Solve a Toeplitz system using Levinson Recursion
    
    The Toeplitz matrix has constant diagonals, with c as its first column
    and r as its first row.  If r is not given, ``r == conjugate(c)`` is
    assumed.
    
    Parameters
    ----------
    c_or_cr : array_like or tuple of (array_like, array_like)
        The vector ``c``, or a tuple of arrays (``c``, ``r``). Whatever the
        actual shape of ``c``, it will be converted to a 1-D array. If not
        supplied, ``r = conjugate(c)`` is assumed; in this case, if c[0] is
        real, the Toeplitz matrix is Hermitian. r[0] is ignored; the first row
        of the Toeplitz matrix is ``[c[0], r[1:]]``.  Whatever the actual shape
        of ``r``, it will be converted to a 1-D array.
    b : (M,) or (M, K) array_like
        Right-hand side in ``T x = b``.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (result entirely NaNs) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : (M,) or (M, K) ndarray
        The solution to the system ``T x = b``.  Shape of return matches shape
        of `b`.
    
    See Also
    --------
    toeplitz : Toeplitz matrix
    
    Notes
    -----
    The solution is computed using Levinson-Durbin recursion, which is faster
    than generic least-squares methods, but can be less numerically stable.
    
    Examples
    --------
    Solve the Toeplitz system T x = b, where::
    
            [ 1 -1 -2 -3]       [1]
        T = [ 3  1 -1 -2]   b = [2]
            [ 6  3  1 -1]       [2]
            [10  6  3  1]       [5]
    
    To specify the Toeplitz matrix, only the first column and the first
    row are needed.
    
    >>> c = np.array([1, 3, 6, 10])    # First column of T
    >>> r = np.array([1, -1, -2, -3])  # First row of T
    >>> b = np.array([1, 2, 2, 5])
    
    >>> from scipy.linalg import solve_toeplitz, toeplitz
    >>> x = solve_toeplitz((c, r), b)
    >>> x
    array([ 1.66666667, -1.        , -2.66666667,  2.33333333])
    
    Check the result by creating the full Toeplitz matrix and
    multiplying it by `x`.  We should get `b`.
    
    >>> T = toeplitz(c, r)
    >>> T.dot(x)
    array([ 1.,  2.,  2.,  5.])
",function,"('c_or_cr', 'b', 'check_finite')","(nan, nan, True)","(nan, nan, 'bool')","('arg_info', 'arg_info', 'arg_info')","('(c_or_cr, b, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.solve_triangular,linalg,solve_triangular,"Python Library Documentation: function solve_triangular in module scipy.linalg.basic

solve_triangular(a, b, trans=0, lower=False, unit_diagonal=False, overwrite_b=False, debug=None, check_finite=True)
    Solve the equation `a x = b` for `x`, assuming a is a triangular matrix.
    
    Parameters
    ----------
    a : (M, M) array_like
        A triangular matrix
    b : (M,) or (M, N) array_like
        Right-hand side matrix in `a x = b`
    lower : bool, optional
        Use only data contained in the lower triangle of `a`.
        Default is to use upper triangle.
    trans : {0, 1, 2, 'N', 'T', 'C'}, optional
        Type of system to solve:
    
        ========  =========
        trans     system
        ========  =========
        0 or 'N'  a x  = b
        1 or 'T'  a^T x = b
        2 or 'C'  a^H x = b
        ========  =========
    unit_diagonal : bool, optional
        If True, diagonal elements of `a` are assumed to be 1 and
        will not be referenced.
    overwrite_b : bool, optional
        Allow overwriting data in `b` (may enhance performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : (M,) or (M, N) ndarray
        Solution to the system `a x = b`.  Shape of return matches `b`.
    
    Raises
    ------
    LinAlgError
        If `a` is singular
    
    Notes
    -----
    .. versionadded:: 0.9.0
    
    Examples
    --------
    Solve the lower triangular system a x = b, where::
    
             [3  0  0  0]       [4]
        a =  [2  1  0  0]   b = [2]
             [1  0  1  0]       [4]
             [1  1  1  1]       [2]
    
    >>> from scipy.linalg import solve_triangular
    >>> a = np.array([[3, 0, 0, 0], [2, 1, 0, 0], [1, 0, 1, 0], [1, 1, 1, 1]])
    >>> b = np.array([4, 2, 4, 2])
    >>> x = solve_triangular(a, b, lower=True)
    >>> x
    array([ 1.33333333, -0.66666667,  2.66666667, -1.33333333])
    >>> a.dot(x)  # Check the result
    array([ 4.,  2.,  4.,  2.])
",function,"('(a, b, trans=0, lower=False, unit_diagonal=False, overwrite_b=False, debug=None, check_finite=True)',)",scipy,1.1.0,scipy.linalg.solve_triangular,linalg,solve_triangular,"Python Library Documentation: function solve_triangular in module scipy.linalg.basic

solve_triangular(a, b, trans=0, lower=False, unit_diagonal=False, overwrite_b=False, debug=None, check_finite=True)
    Solve the equation `a x = b` for `x`, assuming a is a triangular matrix.
    
    Parameters
    ----------
    a : (M, M) array_like
        A triangular matrix
    b : (M,) or (M, N) array_like
        Right-hand side matrix in `a x = b`
    lower : bool, optional
        Use only data contained in the lower triangle of `a`.
        Default is to use upper triangle.
    trans : {0, 1, 2, 'N', 'T', 'C'}, optional
        Type of system to solve:
    
        ========  =========
        trans     system
        ========  =========
        0 or 'N'  a x  = b
        1 or 'T'  a^T x = b
        2 or 'C'  a^H x = b
        ========  =========
    unit_diagonal : bool, optional
        If True, diagonal elements of `a` are assumed to be 1 and
        will not be referenced.
    overwrite_b : bool, optional
        Allow overwriting data in `b` (may enhance performance)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : (M,) or (M, N) ndarray
        Solution to the system `a x = b`.  Shape of return matches `b`.
    
    Raises
    ------
    LinAlgError
        If `a` is singular
    
    Notes
    -----
    .. versionadded:: 0.9.0
    
    Examples
    --------
    Solve the lower triangular system a x = b, where::
    
             [3  0  0  0]       [4]
        a =  [2  1  0  0]   b = [2]
             [1  0  1  0]       [4]
             [1  1  1  1]       [2]
    
    >>> from scipy.linalg import solve_triangular
    >>> a = np.array([[3, 0, 0, 0], [2, 1, 0, 0], [1, 0, 1, 0], [1, 1, 1, 1]])
    >>> b = np.array([4, 2, 4, 2])
    >>> x = solve_triangular(a, b, lower=True)
    >>> x
    array([ 1.33333333, -0.66666667,  2.66666667, -1.33333333])
    >>> a.dot(x)  # Check the result
    array([ 4.,  2.,  4.,  2.])
",function,"('a', 'b', 'trans', 'lower', 'unit_diagonal', 'overwrite_b', 'debug', 'check_finite')","(nan, nan, 0, False, False, False, None, True)","(nan, nan, 'int', 'bool', 'bool', 'bool', 'NoneType', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, b, trans=0, lower=False, unit_diagonal=False, overwrite_b=False, debug=None, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.solveh_banded,linalg,solveh_banded,"Python Library Documentation: function solveh_banded in module scipy.linalg.basic

solveh_banded(ab, b, overwrite_ab=False, overwrite_b=False, lower=False, check_finite=True)
    Solve equation a x = b. a is Hermitian positive-definite banded matrix.
    
    The matrix a is stored in `ab` either in lower diagonal or upper
    diagonal ordered form:
    
        ab[u + i - j, j] == a[i,j]        (if upper form; i <= j)
        ab[    i - j, j] == a[i,j]        (if lower form; i >= j)
    
    Example of `ab` (shape of a is (6, 6), `u` =2)::
    
        upper form:
        *   *   a02 a13 a24 a35
        *   a01 a12 a23 a34 a45
        a00 a11 a22 a33 a44 a55
    
        lower form:
        a00 a11 a22 a33 a44 a55
        a10 a21 a32 a43 a54 *
        a20 a31 a42 a53 *   *
    
    Cells marked with * are not used.
    
    Parameters
    ----------
    ab : (`u` + 1, M) array_like
        Banded matrix
    b : (M,) or (M, K) array_like
        Right-hand side
    overwrite_ab : bool, optional
        Discard data in `ab` (may enhance performance)
    overwrite_b : bool, optional
        Discard data in `b` (may enhance performance)
    lower : bool, optional
        Is the matrix in the lower form. (Default is upper form)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : (M,) or (M, K) ndarray
        The solution to the system a x = b.  Shape of return matches shape
        of `b`.
    
    Examples
    --------
    Solve the banded system A x = b, where::
    
            [ 4  2 -1  0  0  0]       [1]
            [ 2  5  2 -1  0  0]       [2]
        A = [-1  2  6  2 -1  0]   b = [2]
            [ 0 -1  2  7  2 -1]       [3]
            [ 0  0 -1  2  8  2]       [3]
            [ 0  0  0 -1  2  9]       [3]
    
    >>> from scipy.linalg import solveh_banded
    
    `ab` contains the main diagonal and the nonzero diagonals below the
    main diagonal.  That is, we use the lower form:
    
    >>> ab = np.array([[ 4,  5,  6,  7, 8, 9],
    ...                [ 2,  2,  2,  2, 2, 0],
    ...                [-1, -1, -1, -1, 0, 0]])
    >>> b = np.array([1, 2, 2, 3, 3, 3])
    >>> x = solveh_banded(ab, b, lower=True)
    >>> x
    array([ 0.03431373,  0.45938375,  0.05602241,  0.47759104,  0.17577031,
            0.34733894])
    
    
    Solve the Hermitian banded system H x = b, where::
    
            [ 8   2-1j   0     0  ]        [ 1  ]
        H = [2+1j  5     1j    0  ]    b = [1+1j]
            [ 0   -1j    9   -2-1j]        [1-2j]
            [ 0    0   -2+1j   6  ]        [ 0  ]
    
    In this example, we put the upper diagonals in the array `hb`:
    
    >>> hb = np.array([[0, 2-1j, 1j, -2-1j],
    ...                [8,  5,    9,   6  ]])
    >>> b = np.array([1, 1+1j, 1-2j, 0])
    >>> x = solveh_banded(hb, b)
    >>> x
    array([ 0.07318536-0.02939412j,  0.11877624+0.17696461j,
            0.10077984-0.23035393j, -0.00479904-0.09358128j])
",function,"('(ab, b, overwrite_ab=False, overwrite_b=False, lower=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.solveh_banded,linalg,solveh_banded,"Python Library Documentation: function solveh_banded in module scipy.linalg.basic

solveh_banded(ab, b, overwrite_ab=False, overwrite_b=False, lower=False, check_finite=True)
    Solve equation a x = b. a is Hermitian positive-definite banded matrix.
    
    The matrix a is stored in `ab` either in lower diagonal or upper
    diagonal ordered form:
    
        ab[u + i - j, j] == a[i,j]        (if upper form; i <= j)
        ab[    i - j, j] == a[i,j]        (if lower form; i >= j)
    
    Example of `ab` (shape of a is (6, 6), `u` =2)::
    
        upper form:
        *   *   a02 a13 a24 a35
        *   a01 a12 a23 a34 a45
        a00 a11 a22 a33 a44 a55
    
        lower form:
        a00 a11 a22 a33 a44 a55
        a10 a21 a32 a43 a54 *
        a20 a31 a42 a53 *   *
    
    Cells marked with * are not used.
    
    Parameters
    ----------
    ab : (`u` + 1, M) array_like
        Banded matrix
    b : (M,) or (M, K) array_like
        Right-hand side
    overwrite_ab : bool, optional
        Discard data in `ab` (may enhance performance)
    overwrite_b : bool, optional
        Discard data in `b` (may enhance performance)
    lower : bool, optional
        Is the matrix in the lower form. (Default is upper form)
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    x : (M,) or (M, K) ndarray
        The solution to the system a x = b.  Shape of return matches shape
        of `b`.
    
    Examples
    --------
    Solve the banded system A x = b, where::
    
            [ 4  2 -1  0  0  0]       [1]
            [ 2  5  2 -1  0  0]       [2]
        A = [-1  2  6  2 -1  0]   b = [2]
            [ 0 -1  2  7  2 -1]       [3]
            [ 0  0 -1  2  8  2]       [3]
            [ 0  0  0 -1  2  9]       [3]
    
    >>> from scipy.linalg import solveh_banded
    
    `ab` contains the main diagonal and the nonzero diagonals below the
    main diagonal.  That is, we use the lower form:
    
    >>> ab = np.array([[ 4,  5,  6,  7, 8, 9],
    ...                [ 2,  2,  2,  2, 2, 0],
    ...                [-1, -1, -1, -1, 0, 0]])
    >>> b = np.array([1, 2, 2, 3, 3, 3])
    >>> x = solveh_banded(ab, b, lower=True)
    >>> x
    array([ 0.03431373,  0.45938375,  0.05602241,  0.47759104,  0.17577031,
            0.34733894])
    
    
    Solve the Hermitian banded system H x = b, where::
    
            [ 8   2-1j   0     0  ]        [ 1  ]
        H = [2+1j  5     1j    0  ]    b = [1+1j]
            [ 0   -1j    9   -2-1j]        [1-2j]
            [ 0    0   -2+1j   6  ]        [ 0  ]
    
    In this example, we put the upper diagonals in the array `hb`:
    
    >>> hb = np.array([[0, 2-1j, 1j, -2-1j],
    ...                [8,  5,    9,   6  ]])
    >>> b = np.array([1, 1+1j, 1-2j, 0])
    >>> x = solveh_banded(hb, b)
    >>> x
    array([ 0.07318536-0.02939412j,  0.11877624+0.17696461j,
            0.10077984-0.23035393j, -0.00479904-0.09358128j])
",function,"('ab', 'b', 'overwrite_ab', 'overwrite_b', 'lower', 'check_finite')","(nan, nan, False, False, False, True)","(nan, nan, 'bool', 'bool', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(ab, b, overwrite_ab=False, overwrite_b=False, lower=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.special_matrices.as_strided,linalg.special_matrices,as_strided,"Python Library Documentation: function as_strided in module numpy.lib.stride_tricks

as_strided(x, shape=None, strides=None, subok=False, writeable=True)
    Create a view into the array with the given shape and strides.
    
    .. warning:: This function has to be used with extreme care, see notes.
    
    Parameters
    ----------
    x : ndarray
        Array to create a new.
    shape : sequence of int, optional
        The shape of the new array. Defaults to ``x.shape``.
    strides : sequence of int, optional
        The strides of the new array. Defaults to ``x.strides``.
    subok : bool, optional
        .. versionadded:: 1.10
    
        If True, subclasses are preserved.
    writeable : bool, optional
        .. versionadded:: 1.12
    
        If set to False, the returned array will always be readonly.
        Otherwise it will be writable if the original array was. It
        is advisable to set this to False if possible (see Notes).
    
    Returns
    -------
    view : ndarray
    
    See also
    --------
    broadcast_to: broadcast an array to a given shape.
    reshape : reshape an array.
    
    Notes
    -----
    ``as_strided`` creates a view into the array given the exact strides
    and shape. This means it manipulates the internal data structure of
    ndarray and, if done incorrectly, the array elements can point to
    invalid memory and can corrupt results or crash your program.
    It is advisable to always use the original ``x.strides`` when
    calculating new strides to avoid reliance on a contiguous memory
    layout.
    
    Furthermore, arrays created with this function often contain self
    overlapping memory, so that two elements are identical.
    Vectorized write operations on such arrays will typically be
    unpredictable. They may even give different results for small, large,
    or transposed arrays.
    Since writing to these arrays has to be tested and done with great
    care, you may want to use ``writeable=False`` to avoid accidental write
    operations.
    
    For these reasons it is advisable to avoid ``as_strided`` when
    possible.
",function,"('(x, shape=None, strides=None, subok=False, writeable=True)',)",scipy,1.1.0,scipy.linalg.special_matrices.as_strided,linalg.special_matrices,as_strided,"Python Library Documentation: function as_strided in module numpy.lib.stride_tricks

as_strided(x, shape=None, strides=None, subok=False, writeable=True)
    Create a view into the array with the given shape and strides.
    
    .. warning:: This function has to be used with extreme care, see notes.
    
    Parameters
    ----------
    x : ndarray
        Array to create a new.
    shape : sequence of int, optional
        The shape of the new array. Defaults to ``x.shape``.
    strides : sequence of int, optional
        The strides of the new array. Defaults to ``x.strides``.
    subok : bool, optional
        .. versionadded:: 1.10
    
        If True, subclasses are preserved.
    writeable : bool, optional
        .. versionadded:: 1.12
    
        If set to False, the returned array will always be readonly.
        Otherwise it will be writable if the original array was. It
        is advisable to set this to False if possible (see Notes).
    
    Returns
    -------
    view : ndarray
    
    See also
    --------
    broadcast_to: broadcast an array to a given shape.
    reshape : reshape an array.
    
    Notes
    -----
    ``as_strided`` creates a view into the array given the exact strides
    and shape. This means it manipulates the internal data structure of
    ndarray and, if done incorrectly, the array elements can point to
    invalid memory and can corrupt results or crash your program.
    It is advisable to always use the original ``x.strides`` when
    calculating new strides to avoid reliance on a contiguous memory
    layout.
    
    Furthermore, arrays created with this function often contain self
    overlapping memory, so that two elements are identical.
    Vectorized write operations on such arrays will typically be
    unpredictable. They may even give different results for small, large,
    or transposed arrays.
    Since writing to these arrays has to be tested and done with great
    care, you may want to use ``writeable=False`` to avoid accidental write
    operations.
    
    For these reasons it is advisable to avoid ``as_strided`` when
    possible.
",function,"('x', 'shape', 'strides', 'subok', 'writeable')","(nan, None, None, False, True)","(nan, 'NoneType', 'NoneType', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(x, shape=None, strides=None, subok=False, writeable=True)',)"
scipy,1.1.0,scipy.linalg.special_matrices.block_diag,linalg.special_matrices,block_diag,"Python Library Documentation: function block_diag in module scipy.linalg.special_matrices

block_diag(*arrs)
    Create a block diagonal matrix from provided arrays.
    
    Given the inputs `A`, `B` and `C`, the output will have these
    arrays arranged on the diagonal::
    
        [[A, 0, 0],
         [0, B, 0],
         [0, 0, C]]
    
    Parameters
    ----------
    A, B, C, ... : array_like, up to 2-D
        Input arrays.  A 1-D array or array_like sequence of length `n` is
        treated as a 2-D array with shape ``(1,n)``.
    
    Returns
    -------
    D : ndarray
        Array with `A`, `B`, `C`, ... on the diagonal.  `D` has the
        same dtype as `A`.
    
    Notes
    -----
    If all the input arrays are square, the output is known as a
    block diagonal matrix.
    
    Empty sequences (i.e., array-likes of zero size) will not be ignored.
    Noteworthy, both [] and [[]] are treated as matrices with shape ``(1,0)``.
    
    Examples
    --------
    >>> from scipy.linalg import block_diag
    >>> A = [[1, 0],
    ...      [0, 1]]
    >>> B = [[3, 4, 5],
    ...      [6, 7, 8]]
    >>> C = [[7]]
    >>> P = np.zeros((2, 0), dtype='int32')
    >>> block_diag(A, B, C)
    array([[1, 0, 0, 0, 0, 0],
           [0, 1, 0, 0, 0, 0],
           [0, 0, 3, 4, 5, 0],
           [0, 0, 6, 7, 8, 0],
           [0, 0, 0, 0, 0, 7]])
    >>> block_diag(A, P, B, C)
    array([[1, 0, 0, 0, 0, 0],
           [0, 1, 0, 0, 0, 0],
           [0, 0, 0, 0, 0, 0],
           [0, 0, 0, 0, 0, 0],
           [0, 0, 3, 4, 5, 0],
           [0, 0, 6, 7, 8, 0],
           [0, 0, 0, 0, 0, 7]])
    >>> block_diag(1.0, [2, 3], [[4, 5], [6, 7]])
    array([[ 1.,  0.,  0.,  0.,  0.],
           [ 0.,  2.,  3.,  0.,  0.],
           [ 0.,  0.,  0.,  4.,  5.],
           [ 0.,  0.,  0.,  6.,  7.]])
",function,"('(*arrs)',)",scipy,1.1.0,scipy.linalg.special_matrices.block_diag,linalg.special_matrices,block_diag,"Python Library Documentation: function block_diag in module scipy.linalg.special_matrices

block_diag(*arrs)
    Create a block diagonal matrix from provided arrays.
    
    Given the inputs `A`, `B` and `C`, the output will have these
    arrays arranged on the diagonal::
    
        [[A, 0, 0],
         [0, B, 0],
         [0, 0, C]]
    
    Parameters
    ----------
    A, B, C, ... : array_like, up to 2-D
        Input arrays.  A 1-D array or array_like sequence of length `n` is
        treated as a 2-D array with shape ``(1,n)``.
    
    Returns
    -------
    D : ndarray
        Array with `A`, `B`, `C`, ... on the diagonal.  `D` has the
        same dtype as `A`.
    
    Notes
    -----
    If all the input arrays are square, the output is known as a
    block diagonal matrix.
    
    Empty sequences (i.e., array-likes of zero size) will not be ignored.
    Noteworthy, both [] and [[]] are treated as matrices with shape ``(1,0)``.
    
    Examples
    --------
    >>> from scipy.linalg import block_diag
    >>> A = [[1, 0],
    ...      [0, 1]]
    >>> B = [[3, 4, 5],
    ...      [6, 7, 8]]
    >>> C = [[7]]
    >>> P = np.zeros((2, 0), dtype='int32')
    >>> block_diag(A, B, C)
    array([[1, 0, 0, 0, 0, 0],
           [0, 1, 0, 0, 0, 0],
           [0, 0, 3, 4, 5, 0],
           [0, 0, 6, 7, 8, 0],
           [0, 0, 0, 0, 0, 7]])
    >>> block_diag(A, P, B, C)
    array([[1, 0, 0, 0, 0, 0],
           [0, 1, 0, 0, 0, 0],
           [0, 0, 0, 0, 0, 0],
           [0, 0, 0, 0, 0, 0],
           [0, 0, 3, 4, 5, 0],
           [0, 0, 6, 7, 8, 0],
           [0, 0, 0, 0, 0, 7]])
    >>> block_diag(1.0, [2, 3], [[4, 5], [6, 7]])
    array([[ 1.,  0.,  0.,  0.,  0.],
           [ 0.,  2.,  3.,  0.,  0.],
           [ 0.,  0.,  0.,  4.,  5.],
           [ 0.,  0.,  0.,  6.,  7.]])
",function,(),(),(),(),"('(*arrs)',)"
scipy,1.1.0,scipy.linalg.special_matrices.circulant,linalg.special_matrices,circulant,"Python Library Documentation: function circulant in module scipy.linalg.special_matrices

circulant(c)
    Construct a circulant matrix.
    
    Parameters
    ----------
    c : (N,) array_like
        1-D array, the first column of the matrix.
    
    Returns
    -------
    A : (N, N) ndarray
        A circulant matrix whose first column is `c`.
    
    See Also
    --------
    toeplitz : Toeplitz matrix
    hankel : Hankel matrix
    solve_circulant : Solve a circulant system.
    
    Notes
    -----
    .. versionadded:: 0.8.0
    
    Examples
    --------
    >>> from scipy.linalg import circulant
    >>> circulant([1, 2, 3])
    array([[1, 3, 2],
           [2, 1, 3],
           [3, 2, 1]])
",function,"('(c)',)",scipy,1.1.0,scipy.linalg.special_matrices.circulant,linalg.special_matrices,circulant,"Python Library Documentation: function circulant in module scipy.linalg.special_matrices

circulant(c)
    Construct a circulant matrix.
    
    Parameters
    ----------
    c : (N,) array_like
        1-D array, the first column of the matrix.
    
    Returns
    -------
    A : (N, N) ndarray
        A circulant matrix whose first column is `c`.
    
    See Also
    --------
    toeplitz : Toeplitz matrix
    hankel : Hankel matrix
    solve_circulant : Solve a circulant system.
    
    Notes
    -----
    .. versionadded:: 0.8.0
    
    Examples
    --------
    >>> from scipy.linalg import circulant
    >>> circulant([1, 2, 3])
    array([[1, 3, 2],
           [2, 1, 3],
           [3, 2, 1]])
",function,"('c',)","(nan,)","(nan,)","('arg_info',)","('(c)',)"
scipy,1.1.0,scipy.linalg.special_matrices.companion,linalg.special_matrices,companion,"Python Library Documentation: function companion in module scipy.linalg.special_matrices

companion(a)
    Create a companion matrix.
    
    Create the companion matrix [1]_ associated with the polynomial whose
    coefficients are given in `a`.
    
    Parameters
    ----------
    a : (N,) array_like
        1-D array of polynomial coefficients.  The length of `a` must be
        at least two, and ``a[0]`` must not be zero.
    
    Returns
    -------
    c : (N-1, N-1) ndarray
        The first row of `c` is ``-a[1:]/a[0]``, and the first
        sub-diagonal is all ones.  The data-type of the array is the same
        as the data-type of ``1.0*a[0]``.
    
    Raises
    ------
    ValueError
        If any of the following are true: a) ``a.ndim != 1``;
        b) ``a.size < 2``; c) ``a[0] == 0``.
    
    Notes
    -----
    .. versionadded:: 0.8.0
    
    References
    ----------
    .. [1] R. A. Horn & C. R. Johnson, *Matrix Analysis*.  Cambridge, UK:
        Cambridge University Press, 1999, pp. 146-7.
    
    Examples
    --------
    >>> from scipy.linalg import companion
    >>> companion([1, -10, 31, -30])
    array([[ 10., -31.,  30.],
           [  1.,   0.,   0.],
           [  0.,   1.,   0.]])
",function,"('(a)',)",scipy,1.1.0,scipy.linalg.special_matrices.companion,linalg.special_matrices,companion,"Python Library Documentation: function companion in module scipy.linalg.special_matrices

companion(a)
    Create a companion matrix.
    
    Create the companion matrix [1]_ associated with the polynomial whose
    coefficients are given in `a`.
    
    Parameters
    ----------
    a : (N,) array_like
        1-D array of polynomial coefficients.  The length of `a` must be
        at least two, and ``a[0]`` must not be zero.
    
    Returns
    -------
    c : (N-1, N-1) ndarray
        The first row of `c` is ``-a[1:]/a[0]``, and the first
        sub-diagonal is all ones.  The data-type of the array is the same
        as the data-type of ``1.0*a[0]``.
    
    Raises
    ------
    ValueError
        If any of the following are true: a) ``a.ndim != 1``;
        b) ``a.size < 2``; c) ``a[0] == 0``.
    
    Notes
    -----
    .. versionadded:: 0.8.0
    
    References
    ----------
    .. [1] R. A. Horn & C. R. Johnson, *Matrix Analysis*.  Cambridge, UK:
        Cambridge University Press, 1999, pp. 146-7.
    
    Examples
    --------
    >>> from scipy.linalg import companion
    >>> companion([1, -10, 31, -30])
    array([[ 10., -31.,  30.],
           [  1.,   0.,   0.],
           [  0.,   1.,   0.]])
",function,"('a',)","(nan,)","(nan,)","('arg_info',)","('(a)',)"
scipy,1.1.0,scipy.linalg.special_matrices.dft,linalg.special_matrices,dft,"Python Library Documentation: function dft in module scipy.linalg.special_matrices

dft(n, scale=None)
    Discrete Fourier transform matrix.
    
    Create the matrix that computes the discrete Fourier transform of a
    sequence [1]_.  The n-th primitive root of unity used to generate the
    matrix is exp(-2*pi*i/n), where i = sqrt(-1).
    
    Parameters
    ----------
    n : int
        Size the matrix to create.
    scale : str, optional
        Must be None, 'sqrtn', or 'n'.
        If `scale` is 'sqrtn', the matrix is divided by `sqrt(n)`.
        If `scale` is 'n', the matrix is divided by `n`.
        If `scale` is None (the default), the matrix is not normalized, and the
        return value is simply the Vandermonde matrix of the roots of unity.
    
    Returns
    -------
    m : (n, n) ndarray
        The DFT matrix.
    
    Notes
    -----
    When `scale` is None, multiplying a vector by the matrix returned by
    `dft` is mathematically equivalent to (but much less efficient than)
    the calculation performed by `scipy.fftpack.fft`.
    
    .. versionadded:: 0.14.0
    
    References
    ----------
    .. [1] ""DFT matrix"", http://en.wikipedia.org/wiki/DFT_matrix
    
    Examples
    --------
    >>> from scipy.linalg import dft
    >>> np.set_printoptions(precision=5, suppress=True)
    >>> x = np.array([1, 2, 3, 0, 3, 2, 1, 0])
    >>> m = dft(8)
    >>> m.dot(x)   # Compute the DFT of x
    array([ 12.+0.j,  -2.-2.j,   0.-4.j,  -2.+2.j,   4.+0.j,  -2.-2.j,
            -0.+4.j,  -2.+2.j])
    
    Verify that ``m.dot(x)`` is the same as ``fft(x)``.
    
    >>> from scipy.fftpack import fft
    >>> fft(x)     # Same result as m.dot(x)
    array([ 12.+0.j,  -2.-2.j,   0.-4.j,  -2.+2.j,   4.+0.j,  -2.-2.j,
             0.+4.j,  -2.+2.j])
",function,"('(n, scale=None)',)",scipy,1.1.0,scipy.linalg.special_matrices.dft,linalg.special_matrices,dft,"Python Library Documentation: function dft in module scipy.linalg.special_matrices

dft(n, scale=None)
    Discrete Fourier transform matrix.
    
    Create the matrix that computes the discrete Fourier transform of a
    sequence [1]_.  The n-th primitive root of unity used to generate the
    matrix is exp(-2*pi*i/n), where i = sqrt(-1).
    
    Parameters
    ----------
    n : int
        Size the matrix to create.
    scale : str, optional
        Must be None, 'sqrtn', or 'n'.
        If `scale` is 'sqrtn', the matrix is divided by `sqrt(n)`.
        If `scale` is 'n', the matrix is divided by `n`.
        If `scale` is None (the default), the matrix is not normalized, and the
        return value is simply the Vandermonde matrix of the roots of unity.
    
    Returns
    -------
    m : (n, n) ndarray
        The DFT matrix.
    
    Notes
    -----
    When `scale` is None, multiplying a vector by the matrix returned by
    `dft` is mathematically equivalent to (but much less efficient than)
    the calculation performed by `scipy.fftpack.fft`.
    
    .. versionadded:: 0.14.0
    
    References
    ----------
    .. [1] ""DFT matrix"", http://en.wikipedia.org/wiki/DFT_matrix
    
    Examples
    --------
    >>> from scipy.linalg import dft
    >>> np.set_printoptions(precision=5, suppress=True)
    >>> x = np.array([1, 2, 3, 0, 3, 2, 1, 0])
    >>> m = dft(8)
    >>> m.dot(x)   # Compute the DFT of x
    array([ 12.+0.j,  -2.-2.j,   0.-4.j,  -2.+2.j,   4.+0.j,  -2.-2.j,
            -0.+4.j,  -2.+2.j])
    
    Verify that ``m.dot(x)`` is the same as ``fft(x)``.
    
    >>> from scipy.fftpack import fft
    >>> fft(x)     # Same result as m.dot(x)
    array([ 12.+0.j,  -2.-2.j,   0.-4.j,  -2.+2.j,   4.+0.j,  -2.-2.j,
             0.+4.j,  -2.+2.j])
",function,"('n', 'scale')","(nan, None)","(nan, 'NoneType')","('arg_info', 'arg_info')","('(n, scale=None)',)"
scipy,1.1.0,scipy.linalg.special_matrices.hadamard,linalg.special_matrices,hadamard,"Python Library Documentation: function hadamard in module scipy.linalg.special_matrices

hadamard(n, dtype=<class 'int'>)
    Construct a Hadamard matrix.
    
    Constructs an n-by-n Hadamard matrix, using Sylvester's
    construction.  `n` must be a power of 2.
    
    Parameters
    ----------
    n : int
        The order of the matrix.  `n` must be a power of 2.
    dtype : dtype, optional
        The data type of the array to be constructed.
    
    Returns
    -------
    H : (n, n) ndarray
        The Hadamard matrix.
    
    Notes
    -----
    .. versionadded:: 0.8.0
    
    Examples
    --------
    >>> from scipy.linalg import hadamard
    >>> hadamard(2, dtype=complex)
    array([[ 1.+0.j,  1.+0.j],
           [ 1.+0.j, -1.-0.j]])
    >>> hadamard(4)
    array([[ 1,  1,  1,  1],
           [ 1, -1,  1, -1],
           [ 1,  1, -1, -1],
           [ 1, -1, -1,  1]])
",function,"(""(n, dtype=<class 'int'>)"",)",scipy,1.1.0,scipy.linalg.special_matrices.hadamard,linalg.special_matrices,hadamard,"Python Library Documentation: function hadamard in module scipy.linalg.special_matrices

hadamard(n, dtype=<class 'int'>)
    Construct a Hadamard matrix.
    
    Constructs an n-by-n Hadamard matrix, using Sylvester's
    construction.  `n` must be a power of 2.
    
    Parameters
    ----------
    n : int
        The order of the matrix.  `n` must be a power of 2.
    dtype : dtype, optional
        The data type of the array to be constructed.
    
    Returns
    -------
    H : (n, n) ndarray
        The Hadamard matrix.
    
    Notes
    -----
    .. versionadded:: 0.8.0
    
    Examples
    --------
    >>> from scipy.linalg import hadamard
    >>> hadamard(2, dtype=complex)
    array([[ 1.+0.j,  1.+0.j],
           [ 1.+0.j, -1.-0.j]])
    >>> hadamard(4)
    array([[ 1,  1,  1,  1],
           [ 1, -1,  1, -1],
           [ 1,  1, -1, -1],
           [ 1, -1, -1,  1]])
",function,"('n', 'dtype')","(nan, <class 'int'>)","(nan, 'type')","('arg_info', 'arg_info')","(""(n, dtype=<class 'int'>)"",)"
scipy,1.1.0,scipy.linalg.special_matrices.hankel,linalg.special_matrices,hankel,"Python Library Documentation: function hankel in module scipy.linalg.special_matrices

hankel(c, r=None)
    Construct a Hankel matrix.
    
    The Hankel matrix has constant anti-diagonals, with `c` as its
    first column and `r` as its last row.  If `r` is not given, then
    `r = zeros_like(c)` is assumed.
    
    Parameters
    ----------
    c : array_like
        First column of the matrix.  Whatever the actual shape of `c`, it
        will be converted to a 1-D array.
    r : array_like, optional
        Last row of the matrix. If None, ``r = zeros_like(c)`` is assumed.
        r[0] is ignored; the last row of the returned matrix is
        ``[c[-1], r[1:]]``.  Whatever the actual shape of `r`, it will be
        converted to a 1-D array.
    
    Returns
    -------
    A : (len(c), len(r)) ndarray
        The Hankel matrix. Dtype is the same as ``(c[0] + r[0]).dtype``.
    
    See Also
    --------
    toeplitz : Toeplitz matrix
    circulant : circulant matrix
    
    Examples
    --------
    >>> from scipy.linalg import hankel
    >>> hankel([1, 17, 99])
    array([[ 1, 17, 99],
           [17, 99,  0],
           [99,  0,  0]])
    >>> hankel([1,2,3,4], [4,7,7,8,9])
    array([[1, 2, 3, 4, 7],
           [2, 3, 4, 7, 7],
           [3, 4, 7, 7, 8],
           [4, 7, 7, 8, 9]])
",function,"('(c, r=None)',)",scipy,1.1.0,scipy.linalg.special_matrices.hankel,linalg.special_matrices,hankel,"Python Library Documentation: function hankel in module scipy.linalg.special_matrices

hankel(c, r=None)
    Construct a Hankel matrix.
    
    The Hankel matrix has constant anti-diagonals, with `c` as its
    first column and `r` as its last row.  If `r` is not given, then
    `r = zeros_like(c)` is assumed.
    
    Parameters
    ----------
    c : array_like
        First column of the matrix.  Whatever the actual shape of `c`, it
        will be converted to a 1-D array.
    r : array_like, optional
        Last row of the matrix. If None, ``r = zeros_like(c)`` is assumed.
        r[0] is ignored; the last row of the returned matrix is
        ``[c[-1], r[1:]]``.  Whatever the actual shape of `r`, it will be
        converted to a 1-D array.
    
    Returns
    -------
    A : (len(c), len(r)) ndarray
        The Hankel matrix. Dtype is the same as ``(c[0] + r[0]).dtype``.
    
    See Also
    --------
    toeplitz : Toeplitz matrix
    circulant : circulant matrix
    
    Examples
    --------
    >>> from scipy.linalg import hankel
    >>> hankel([1, 17, 99])
    array([[ 1, 17, 99],
           [17, 99,  0],
           [99,  0,  0]])
    >>> hankel([1,2,3,4], [4,7,7,8,9])
    array([[1, 2, 3, 4, 7],
           [2, 3, 4, 7, 7],
           [3, 4, 7, 7, 8],
           [4, 7, 7, 8, 9]])
",function,"('c', 'r')","(nan, None)","(nan, 'NoneType')","('arg_info', 'arg_info')","('(c, r=None)',)"
scipy,1.1.0,scipy.linalg.special_matrices.helmert,linalg.special_matrices,helmert,"Python Library Documentation: function helmert in module scipy.linalg.special_matrices

helmert(n, full=False)
    Create a Helmert matrix of order `n`.
    
    This has applications in statistics, compositional or simplicial analysis,
    and in Aitchison geometry.
    
    Parameters
    ----------
    n : int
        The size of the array to create.
    full : bool, optional
        If True the (n, n) ndarray will be returned.
        Otherwise the submatrix that does not include the first
        row will be returned.
        Default: False.
    
    Returns
    -------
    M : ndarray
        The Helmert matrix.
        The shape is (n, n) or (n-1, n) depending on the `full` argument.
    
    Examples
    --------
    >>> from scipy.linalg import helmert
    >>> helmert(5, full=True)
    array([[ 0.4472136 ,  0.4472136 ,  0.4472136 ,  0.4472136 ,  0.4472136 ],
           [ 0.70710678, -0.70710678,  0.        ,  0.        ,  0.        ],
           [ 0.40824829,  0.40824829, -0.81649658,  0.        ,  0.        ],
           [ 0.28867513,  0.28867513,  0.28867513, -0.8660254 ,  0.        ],
           [ 0.2236068 ,  0.2236068 ,  0.2236068 ,  0.2236068 , -0.89442719]])
",function,"('(n, full=False)',)",scipy,1.1.0,scipy.linalg.special_matrices.helmert,linalg.special_matrices,helmert,"Python Library Documentation: function helmert in module scipy.linalg.special_matrices

helmert(n, full=False)
    Create a Helmert matrix of order `n`.
    
    This has applications in statistics, compositional or simplicial analysis,
    and in Aitchison geometry.
    
    Parameters
    ----------
    n : int
        The size of the array to create.
    full : bool, optional
        If True the (n, n) ndarray will be returned.
        Otherwise the submatrix that does not include the first
        row will be returned.
        Default: False.
    
    Returns
    -------
    M : ndarray
        The Helmert matrix.
        The shape is (n, n) or (n-1, n) depending on the `full` argument.
    
    Examples
    --------
    >>> from scipy.linalg import helmert
    >>> helmert(5, full=True)
    array([[ 0.4472136 ,  0.4472136 ,  0.4472136 ,  0.4472136 ,  0.4472136 ],
           [ 0.70710678, -0.70710678,  0.        ,  0.        ,  0.        ],
           [ 0.40824829,  0.40824829, -0.81649658,  0.        ,  0.        ],
           [ 0.28867513,  0.28867513,  0.28867513, -0.8660254 ,  0.        ],
           [ 0.2236068 ,  0.2236068 ,  0.2236068 ,  0.2236068 , -0.89442719]])
",function,"('n', 'full')","(nan, False)","(nan, 'bool')","('arg_info', 'arg_info')","('(n, full=False)',)"
scipy,1.1.0,scipy.linalg.special_matrices.hilbert,linalg.special_matrices,hilbert,"Python Library Documentation: function hilbert in module scipy.linalg.special_matrices

hilbert(n)
    Create a Hilbert matrix of order `n`.
    
    Returns the `n` by `n` array with entries `h[i,j] = 1 / (i + j + 1)`.
    
    Parameters
    ----------
    n : int
        The size of the array to create.
    
    Returns
    -------
    h : (n, n) ndarray
        The Hilbert matrix.
    
    See Also
    --------
    invhilbert : Compute the inverse of a Hilbert matrix.
    
    Notes
    -----
    .. versionadded:: 0.10.0
    
    Examples
    --------
    >>> from scipy.linalg import hilbert
    >>> hilbert(3)
    array([[ 1.        ,  0.5       ,  0.33333333],
           [ 0.5       ,  0.33333333,  0.25      ],
           [ 0.33333333,  0.25      ,  0.2       ]])
",function,"('(n)',)",scipy,1.1.0,scipy.linalg.special_matrices.hilbert,linalg.special_matrices,hilbert,"Python Library Documentation: function hilbert in module scipy.linalg.special_matrices

hilbert(n)
    Create a Hilbert matrix of order `n`.
    
    Returns the `n` by `n` array with entries `h[i,j] = 1 / (i + j + 1)`.
    
    Parameters
    ----------
    n : int
        The size of the array to create.
    
    Returns
    -------
    h : (n, n) ndarray
        The Hilbert matrix.
    
    See Also
    --------
    invhilbert : Compute the inverse of a Hilbert matrix.
    
    Notes
    -----
    .. versionadded:: 0.10.0
    
    Examples
    --------
    >>> from scipy.linalg import hilbert
    >>> hilbert(3)
    array([[ 1.        ,  0.5       ,  0.33333333],
           [ 0.5       ,  0.33333333,  0.25      ],
           [ 0.33333333,  0.25      ,  0.2       ]])
",function,"('n',)","(nan,)","(nan,)","('arg_info',)","('(n)',)"
scipy,1.1.0,scipy.linalg.special_matrices.invhilbert,linalg.special_matrices,invhilbert,"Python Library Documentation: function invhilbert in module scipy.linalg.special_matrices

invhilbert(n, exact=False)
    Compute the inverse of the Hilbert matrix of order `n`.
    
    The entries in the inverse of a Hilbert matrix are integers.  When `n`
    is greater than 14, some entries in the inverse exceed the upper limit
    of 64 bit integers.  The `exact` argument provides two options for
    dealing with these large integers.
    
    Parameters
    ----------
    n : int
        The order of the Hilbert matrix.
    exact : bool, optional
        If False, the data type of the array that is returned is np.float64,
        and the array is an approximation of the inverse.
        If True, the array is the exact integer inverse array.  To represent
        the exact inverse when n > 14, the returned array is an object array
        of long integers.  For n <= 14, the exact inverse is returned as an
        array with data type np.int64.
    
    Returns
    -------
    invh : (n, n) ndarray
        The data type of the array is np.float64 if `exact` is False.
        If `exact` is True, the data type is either np.int64 (for n <= 14)
        or object (for n > 14).  In the latter case, the objects in the
        array will be long integers.
    
    See Also
    --------
    hilbert : Create a Hilbert matrix.
    
    Notes
    -----
    .. versionadded:: 0.10.0
    
    Examples
    --------
    >>> from scipy.linalg import invhilbert
    >>> invhilbert(4)
    array([[   16.,  -120.,   240.,  -140.],
           [ -120.,  1200., -2700.,  1680.],
           [  240., -2700.,  6480., -4200.],
           [ -140.,  1680., -4200.,  2800.]])
    >>> invhilbert(4, exact=True)
    array([[   16,  -120,   240,  -140],
           [ -120,  1200, -2700,  1680],
           [  240, -2700,  6480, -4200],
           [ -140,  1680, -4200,  2800]], dtype=int64)
    >>> invhilbert(16)[7,7]
    4.2475099528537506e+19
    >>> invhilbert(16, exact=True)[7,7]
    42475099528537378560L
",function,"('(n, exact=False)',)",scipy,1.1.0,scipy.linalg.special_matrices.invhilbert,linalg.special_matrices,invhilbert,"Python Library Documentation: function invhilbert in module scipy.linalg.special_matrices

invhilbert(n, exact=False)
    Compute the inverse of the Hilbert matrix of order `n`.
    
    The entries in the inverse of a Hilbert matrix are integers.  When `n`
    is greater than 14, some entries in the inverse exceed the upper limit
    of 64 bit integers.  The `exact` argument provides two options for
    dealing with these large integers.
    
    Parameters
    ----------
    n : int
        The order of the Hilbert matrix.
    exact : bool, optional
        If False, the data type of the array that is returned is np.float64,
        and the array is an approximation of the inverse.
        If True, the array is the exact integer inverse array.  To represent
        the exact inverse when n > 14, the returned array is an object array
        of long integers.  For n <= 14, the exact inverse is returned as an
        array with data type np.int64.
    
    Returns
    -------
    invh : (n, n) ndarray
        The data type of the array is np.float64 if `exact` is False.
        If `exact` is True, the data type is either np.int64 (for n <= 14)
        or object (for n > 14).  In the latter case, the objects in the
        array will be long integers.
    
    See Also
    --------
    hilbert : Create a Hilbert matrix.
    
    Notes
    -----
    .. versionadded:: 0.10.0
    
    Examples
    --------
    >>> from scipy.linalg import invhilbert
    >>> invhilbert(4)
    array([[   16.,  -120.,   240.,  -140.],
           [ -120.,  1200., -2700.,  1680.],
           [  240., -2700.,  6480., -4200.],
           [ -140.,  1680., -4200.,  2800.]])
    >>> invhilbert(4, exact=True)
    array([[   16,  -120,   240,  -140],
           [ -120,  1200, -2700,  1680],
           [  240, -2700,  6480, -4200],
           [ -140,  1680, -4200,  2800]], dtype=int64)
    >>> invhilbert(16)[7,7]
    4.2475099528537506e+19
    >>> invhilbert(16, exact=True)[7,7]
    42475099528537378560L
",function,"('n', 'exact')","(nan, False)","(nan, 'bool')","('arg_info', 'arg_info')","('(n, exact=False)',)"
scipy,1.1.0,scipy.linalg.special_matrices.invpascal,linalg.special_matrices,invpascal,"Python Library Documentation: function invpascal in module scipy.linalg.special_matrices

invpascal(n, kind='symmetric', exact=True)
    Returns the inverse of the n x n Pascal matrix.
    
    The Pascal matrix is a matrix containing the binomial coefficients as
    its elements.
    
    Parameters
    ----------
    n : int
        The size of the matrix to create; that is, the result is an n x n
        matrix.
    kind : str, optional
        Must be one of 'symmetric', 'lower', or 'upper'.
        Default is 'symmetric'.
    exact : bool, optional
        If `exact` is True, the result is either an array of type
        `numpy.int64` (if `n` <= 35) or an object array of Python integers.
        If `exact` is False, the coefficients in the matrix are computed using
        `scipy.special.comb` with `exact=False`.  The result will be a floating
        point array, and for large `n`, the values in the array will not be the
        exact coefficients.
    
    Returns
    -------
    invp : (n, n) ndarray
        The inverse of the Pascal matrix.
    
    See Also
    --------
    pascal
    
    Notes
    -----
    
    .. versionadded:: 0.16.0
    
    References
    ----------
    .. [1] ""Pascal matrix"",  http://en.wikipedia.org/wiki/Pascal_matrix
    .. [2] Cohen, A. M., ""The inverse of a Pascal matrix"", Mathematical
           Gazette, 59(408), pp. 111-112, 1975.
    
    Examples
    --------
    >>> from scipy.linalg import invpascal, pascal
    >>> invp = invpascal(5)
    >>> invp
    array([[  5, -10,  10,  -5,   1],
           [-10,  30, -35,  19,  -4],
           [ 10, -35,  46, -27,   6],
           [ -5,  19, -27,  17,  -4],
           [  1,  -4,   6,  -4,   1]])
    
    >>> p = pascal(5)
    >>> p.dot(invp)
    array([[ 1.,  0.,  0.,  0.,  0.],
           [ 0.,  1.,  0.,  0.,  0.],
           [ 0.,  0.,  1.,  0.,  0.],
           [ 0.,  0.,  0.,  1.,  0.],
           [ 0.,  0.,  0.,  0.,  1.]])
    
    An example of the use of `kind` and `exact`:
    
    >>> invpascal(5, kind='lower', exact=False)
    array([[ 1., -0.,  0., -0.,  0.],
           [-1.,  1., -0.,  0., -0.],
           [ 1., -2.,  1., -0.,  0.],
           [-1.,  3., -3.,  1., -0.],
           [ 1., -4.,  6., -4.,  1.]])
",function,"(""(n, kind='symmetric', exact=True)"",)",scipy,1.1.0,scipy.linalg.special_matrices.invpascal,linalg.special_matrices,invpascal,"Python Library Documentation: function invpascal in module scipy.linalg.special_matrices

invpascal(n, kind='symmetric', exact=True)
    Returns the inverse of the n x n Pascal matrix.
    
    The Pascal matrix is a matrix containing the binomial coefficients as
    its elements.
    
    Parameters
    ----------
    n : int
        The size of the matrix to create; that is, the result is an n x n
        matrix.
    kind : str, optional
        Must be one of 'symmetric', 'lower', or 'upper'.
        Default is 'symmetric'.
    exact : bool, optional
        If `exact` is True, the result is either an array of type
        `numpy.int64` (if `n` <= 35) or an object array of Python integers.
        If `exact` is False, the coefficients in the matrix are computed using
        `scipy.special.comb` with `exact=False`.  The result will be a floating
        point array, and for large `n`, the values in the array will not be the
        exact coefficients.
    
    Returns
    -------
    invp : (n, n) ndarray
        The inverse of the Pascal matrix.
    
    See Also
    --------
    pascal
    
    Notes
    -----
    
    .. versionadded:: 0.16.0
    
    References
    ----------
    .. [1] ""Pascal matrix"",  http://en.wikipedia.org/wiki/Pascal_matrix
    .. [2] Cohen, A. M., ""The inverse of a Pascal matrix"", Mathematical
           Gazette, 59(408), pp. 111-112, 1975.
    
    Examples
    --------
    >>> from scipy.linalg import invpascal, pascal
    >>> invp = invpascal(5)
    >>> invp
    array([[  5, -10,  10,  -5,   1],
           [-10,  30, -35,  19,  -4],
           [ 10, -35,  46, -27,   6],
           [ -5,  19, -27,  17,  -4],
           [  1,  -4,   6,  -4,   1]])
    
    >>> p = pascal(5)
    >>> p.dot(invp)
    array([[ 1.,  0.,  0.,  0.,  0.],
           [ 0.,  1.,  0.,  0.,  0.],
           [ 0.,  0.,  1.,  0.,  0.],
           [ 0.,  0.,  0.,  1.,  0.],
           [ 0.,  0.,  0.,  0.,  1.]])
    
    An example of the use of `kind` and `exact`:
    
    >>> invpascal(5, kind='lower', exact=False)
    array([[ 1., -0.,  0., -0.,  0.],
           [-1.,  1., -0.,  0., -0.],
           [ 1., -2.,  1., -0.,  0.],
           [-1.,  3., -3.,  1., -0.],
           [ 1., -4.,  6., -4.,  1.]])
",function,"('n', 'kind', 'exact')","(nan, 'symmetric', True)","(nan, 'str', 'bool')","('arg_info', 'arg_info', 'arg_info')","(""(n, kind='symmetric', exact=True)"",)"
scipy,1.1.0,scipy.linalg.special_matrices.kron,linalg.special_matrices,kron,"Python Library Documentation: function kron in module scipy.linalg.special_matrices

kron(a, b)
    Kronecker product.
    
    The result is the block matrix::
    
        a[0,0]*b    a[0,1]*b  ... a[0,-1]*b
        a[1,0]*b    a[1,1]*b  ... a[1,-1]*b
        ...
        a[-1,0]*b   a[-1,1]*b ... a[-1,-1]*b
    
    Parameters
    ----------
    a : (M, N) ndarray
        Input array
    b : (P, Q) ndarray
        Input array
    
    Returns
    -------
    A : (M*P, N*Q) ndarray
        Kronecker product of `a` and `b`.
    
    Examples
    --------
    >>> from numpy import array
    >>> from scipy.linalg import kron
    >>> kron(array([[1,2],[3,4]]), array([[1,1,1]]))
    array([[1, 1, 1, 2, 2, 2],
           [3, 3, 3, 4, 4, 4]])
",function,"('(a, b)',)",scipy,1.1.0,scipy.linalg.special_matrices.kron,linalg.special_matrices,kron,"Python Library Documentation: function kron in module scipy.linalg.special_matrices

kron(a, b)
    Kronecker product.
    
    The result is the block matrix::
    
        a[0,0]*b    a[0,1]*b  ... a[0,-1]*b
        a[1,0]*b    a[1,1]*b  ... a[1,-1]*b
        ...
        a[-1,0]*b   a[-1,1]*b ... a[-1,-1]*b
    
    Parameters
    ----------
    a : (M, N) ndarray
        Input array
    b : (P, Q) ndarray
        Input array
    
    Returns
    -------
    A : (M*P, N*Q) ndarray
        Kronecker product of `a` and `b`.
    
    Examples
    --------
    >>> from numpy import array
    >>> from scipy.linalg import kron
    >>> kron(array([[1,2],[3,4]]), array([[1,1,1]]))
    array([[1, 1, 1, 2, 2, 2],
           [3, 3, 3, 4, 4, 4]])
",function,"('a', 'b')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(a, b)',)"
scipy,1.1.0,scipy.linalg.special_matrices.leslie,linalg.special_matrices,leslie,"Python Library Documentation: function leslie in module scipy.linalg.special_matrices

leslie(f, s)
    Create a Leslie matrix.
    
    Given the length n array of fecundity coefficients `f` and the length
    n-1 array of survival coefficients `s`, return the associated Leslie matrix.
    
    Parameters
    ----------
    f : (N,) array_like
        The ""fecundity"" coefficients.
    s : (N-1,) array_like
        The ""survival"" coefficients, has to be 1-D.  The length of `s`
        must be one less than the length of `f`, and it must be at least 1.
    
    Returns
    -------
    L : (N, N) ndarray
        The array is zero except for the first row,
        which is `f`, and the first sub-diagonal, which is `s`.
        The data-type of the array will be the data-type of ``f[0]+s[0]``.
    
    Notes
    -----
    .. versionadded:: 0.8.0
    
    The Leslie matrix is used to model discrete-time, age-structured
    population growth [1]_ [2]_. In a population with `n` age classes, two sets
    of parameters define a Leslie matrix: the `n` ""fecundity coefficients"",
    which give the number of offspring per-capita produced by each age
    class, and the `n` - 1 ""survival coefficients"", which give the
    per-capita survival rate of each age class.
    
    References
    ----------
    .. [1] P. H. Leslie, On the use of matrices in certain population
           mathematics, Biometrika, Vol. 33, No. 3, 183--212 (Nov. 1945)
    .. [2] P. H. Leslie, Some further notes on the use of matrices in
           population mathematics, Biometrika, Vol. 35, No. 3/4, 213--245
           (Dec. 1948)
    
    Examples
    --------
    >>> from scipy.linalg import leslie
    >>> leslie([0.1, 2.0, 1.0, 0.1], [0.2, 0.8, 0.7])
    array([[ 0.1,  2. ,  1. ,  0.1],
           [ 0.2,  0. ,  0. ,  0. ],
           [ 0. ,  0.8,  0. ,  0. ],
           [ 0. ,  0. ,  0.7,  0. ]])
",function,"('(f, s)',)",scipy,1.1.0,scipy.linalg.special_matrices.leslie,linalg.special_matrices,leslie,"Python Library Documentation: function leslie in module scipy.linalg.special_matrices

leslie(f, s)
    Create a Leslie matrix.
    
    Given the length n array of fecundity coefficients `f` and the length
    n-1 array of survival coefficients `s`, return the associated Leslie matrix.
    
    Parameters
    ----------
    f : (N,) array_like
        The ""fecundity"" coefficients.
    s : (N-1,) array_like
        The ""survival"" coefficients, has to be 1-D.  The length of `s`
        must be one less than the length of `f`, and it must be at least 1.
    
    Returns
    -------
    L : (N, N) ndarray
        The array is zero except for the first row,
        which is `f`, and the first sub-diagonal, which is `s`.
        The data-type of the array will be the data-type of ``f[0]+s[0]``.
    
    Notes
    -----
    .. versionadded:: 0.8.0
    
    The Leslie matrix is used to model discrete-time, age-structured
    population growth [1]_ [2]_. In a population with `n` age classes, two sets
    of parameters define a Leslie matrix: the `n` ""fecundity coefficients"",
    which give the number of offspring per-capita produced by each age
    class, and the `n` - 1 ""survival coefficients"", which give the
    per-capita survival rate of each age class.
    
    References
    ----------
    .. [1] P. H. Leslie, On the use of matrices in certain population
           mathematics, Biometrika, Vol. 33, No. 3, 183--212 (Nov. 1945)
    .. [2] P. H. Leslie, Some further notes on the use of matrices in
           population mathematics, Biometrika, Vol. 35, No. 3/4, 213--245
           (Dec. 1948)
    
    Examples
    --------
    >>> from scipy.linalg import leslie
    >>> leslie([0.1, 2.0, 1.0, 0.1], [0.2, 0.8, 0.7])
    array([[ 0.1,  2. ,  1. ,  0.1],
           [ 0.2,  0. ,  0. ,  0. ],
           [ 0. ,  0.8,  0. ,  0. ],
           [ 0. ,  0. ,  0.7,  0. ]])
",function,"('f', 's')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(f, s)',)"
scipy,1.1.0,scipy.linalg.special_matrices.pascal,linalg.special_matrices,pascal,"Python Library Documentation: function pascal in module scipy.linalg.special_matrices

pascal(n, kind='symmetric', exact=True)
    Returns the n x n Pascal matrix.
    
    The Pascal matrix is a matrix containing the binomial coefficients as
    its elements.
    
    Parameters
    ----------
    n : int
        The size of the matrix to create; that is, the result is an n x n
        matrix.
    kind : str, optional
        Must be one of 'symmetric', 'lower', or 'upper'.
        Default is 'symmetric'.
    exact : bool, optional
        If `exact` is True, the result is either an array of type
        numpy.uint64 (if n < 35) or an object array of Python long integers.
        If `exact` is False, the coefficients in the matrix are computed using
        `scipy.special.comb` with `exact=False`.  The result will be a floating
        point array, and the values in the array will not be the exact
        coefficients, but this version is much faster than `exact=True`.
    
    Returns
    -------
    p : (n, n) ndarray
        The Pascal matrix.
    
    See Also
    --------
    invpascal
    
    Notes
    -----
    See http://en.wikipedia.org/wiki/Pascal_matrix for more information
    about Pascal matrices.
    
    .. versionadded:: 0.11.0
    
    Examples
    --------
    >>> from scipy.linalg import pascal
    >>> pascal(4)
    array([[ 1,  1,  1,  1],
           [ 1,  2,  3,  4],
           [ 1,  3,  6, 10],
           [ 1,  4, 10, 20]], dtype=uint64)
    >>> pascal(4, kind='lower')
    array([[1, 0, 0, 0],
           [1, 1, 0, 0],
           [1, 2, 1, 0],
           [1, 3, 3, 1]], dtype=uint64)
    >>> pascal(50)[-1, -1]
    25477612258980856902730428600L
    >>> from scipy.special import comb
    >>> comb(98, 49, exact=True)
    25477612258980856902730428600L
",function,"(""(n, kind='symmetric', exact=True)"",)",scipy,1.1.0,scipy.linalg.special_matrices.pascal,linalg.special_matrices,pascal,"Python Library Documentation: function pascal in module scipy.linalg.special_matrices

pascal(n, kind='symmetric', exact=True)
    Returns the n x n Pascal matrix.
    
    The Pascal matrix is a matrix containing the binomial coefficients as
    its elements.
    
    Parameters
    ----------
    n : int
        The size of the matrix to create; that is, the result is an n x n
        matrix.
    kind : str, optional
        Must be one of 'symmetric', 'lower', or 'upper'.
        Default is 'symmetric'.
    exact : bool, optional
        If `exact` is True, the result is either an array of type
        numpy.uint64 (if n < 35) or an object array of Python long integers.
        If `exact` is False, the coefficients in the matrix are computed using
        `scipy.special.comb` with `exact=False`.  The result will be a floating
        point array, and the values in the array will not be the exact
        coefficients, but this version is much faster than `exact=True`.
    
    Returns
    -------
    p : (n, n) ndarray
        The Pascal matrix.
    
    See Also
    --------
    invpascal
    
    Notes
    -----
    See http://en.wikipedia.org/wiki/Pascal_matrix for more information
    about Pascal matrices.
    
    .. versionadded:: 0.11.0
    
    Examples
    --------
    >>> from scipy.linalg import pascal
    >>> pascal(4)
    array([[ 1,  1,  1,  1],
           [ 1,  2,  3,  4],
           [ 1,  3,  6, 10],
           [ 1,  4, 10, 20]], dtype=uint64)
    >>> pascal(4, kind='lower')
    array([[1, 0, 0, 0],
           [1, 1, 0, 0],
           [1, 2, 1, 0],
           [1, 3, 3, 1]], dtype=uint64)
    >>> pascal(50)[-1, -1]
    25477612258980856902730428600L
    >>> from scipy.special import comb
    >>> comb(98, 49, exact=True)
    25477612258980856902730428600L
",function,"('n', 'kind', 'exact')","(nan, 'symmetric', True)","(nan, 'str', 'bool')","('arg_info', 'arg_info', 'arg_info')","(""(n, kind='symmetric', exact=True)"",)"
scipy,1.1.0,scipy.linalg.special_matrices.toeplitz,linalg.special_matrices,toeplitz,"Python Library Documentation: function toeplitz in module scipy.linalg.special_matrices

toeplitz(c, r=None)
    Construct a Toeplitz matrix.
    
    The Toeplitz matrix has constant diagonals, with c as its first column
    and r as its first row.  If r is not given, ``r == conjugate(c)`` is
    assumed.
    
    Parameters
    ----------
    c : array_like
        First column of the matrix.  Whatever the actual shape of `c`, it
        will be converted to a 1-D array.
    r : array_like, optional
        First row of the matrix. If None, ``r = conjugate(c)`` is assumed;
        in this case, if c[0] is real, the result is a Hermitian matrix.
        r[0] is ignored; the first row of the returned matrix is
        ``[c[0], r[1:]]``.  Whatever the actual shape of `r`, it will be
        converted to a 1-D array.
    
    Returns
    -------
    A : (len(c), len(r)) ndarray
        The Toeplitz matrix. Dtype is the same as ``(c[0] + r[0]).dtype``.
    
    See Also
    --------
    circulant : circulant matrix
    hankel : Hankel matrix
    solve_toeplitz : Solve a Toeplitz system.
    
    Notes
    -----
    The behavior when `c` or `r` is a scalar, or when `c` is complex and
    `r` is None, was changed in version 0.8.0.  The behavior in previous
    versions was undocumented and is no longer supported.
    
    Examples
    --------
    >>> from scipy.linalg import toeplitz
    >>> toeplitz([1,2,3], [1,4,5,6])
    array([[1, 4, 5, 6],
           [2, 1, 4, 5],
           [3, 2, 1, 4]])
    >>> toeplitz([1.0, 2+3j, 4-1j])
    array([[ 1.+0.j,  2.-3.j,  4.+1.j],
           [ 2.+3.j,  1.+0.j,  2.-3.j],
           [ 4.-1.j,  2.+3.j,  1.+0.j]])
",function,"('(c, r=None)',)",scipy,1.1.0,scipy.linalg.special_matrices.toeplitz,linalg.special_matrices,toeplitz,"Python Library Documentation: function toeplitz in module scipy.linalg.special_matrices

toeplitz(c, r=None)
    Construct a Toeplitz matrix.
    
    The Toeplitz matrix has constant diagonals, with c as its first column
    and r as its first row.  If r is not given, ``r == conjugate(c)`` is
    assumed.
    
    Parameters
    ----------
    c : array_like
        First column of the matrix.  Whatever the actual shape of `c`, it
        will be converted to a 1-D array.
    r : array_like, optional
        First row of the matrix. If None, ``r = conjugate(c)`` is assumed;
        in this case, if c[0] is real, the result is a Hermitian matrix.
        r[0] is ignored; the first row of the returned matrix is
        ``[c[0], r[1:]]``.  Whatever the actual shape of `r`, it will be
        converted to a 1-D array.
    
    Returns
    -------
    A : (len(c), len(r)) ndarray
        The Toeplitz matrix. Dtype is the same as ``(c[0] + r[0]).dtype``.
    
    See Also
    --------
    circulant : circulant matrix
    hankel : Hankel matrix
    solve_toeplitz : Solve a Toeplitz system.
    
    Notes
    -----
    The behavior when `c` or `r` is a scalar, or when `c` is complex and
    `r` is None, was changed in version 0.8.0.  The behavior in previous
    versions was undocumented and is no longer supported.
    
    Examples
    --------
    >>> from scipy.linalg import toeplitz
    >>> toeplitz([1,2,3], [1,4,5,6])
    array([[1, 4, 5, 6],
           [2, 1, 4, 5],
           [3, 2, 1, 4]])
    >>> toeplitz([1.0, 2+3j, 4-1j])
    array([[ 1.+0.j,  2.-3.j,  4.+1.j],
           [ 2.+3.j,  1.+0.j,  2.-3.j],
           [ 4.-1.j,  2.+3.j,  1.+0.j]])
",function,"('c', 'r')","(nan, None)","(nan, 'NoneType')","('arg_info', 'arg_info')","('(c, r=None)',)"
scipy,1.1.0,scipy.linalg.special_matrices.tri,linalg.special_matrices,tri,"Python Library Documentation: function tri in module scipy.linalg.special_matrices

tri(N, M=None, k=0, dtype=None)
    Construct (N, M) matrix filled with ones at and below the k-th diagonal.
    
    The matrix has A[i,j] == 1 for i <= j + k
    
    Parameters
    ----------
    N : int
        The size of the first dimension of the matrix.
    M : int or None, optional
        The size of the second dimension of the matrix. If `M` is None,
        `M = N` is assumed.
    k : int, optional
        Number of subdiagonal below which matrix is filled with ones.
        `k` = 0 is the main diagonal, `k` < 0 subdiagonal and `k` > 0
        superdiagonal.
    dtype : dtype, optional
        Data type of the matrix.
    
    Returns
    -------
    tri : (N, M) ndarray
        Tri matrix.
    
    Examples
    --------
    >>> from scipy.linalg import tri
    >>> tri(3, 5, 2, dtype=int)
    array([[1, 1, 1, 0, 0],
           [1, 1, 1, 1, 0],
           [1, 1, 1, 1, 1]])
    >>> tri(3, 5, -1, dtype=int)
    array([[0, 0, 0, 0, 0],
           [1, 0, 0, 0, 0],
           [1, 1, 0, 0, 0]])
",function,"('(N, M=None, k=0, dtype=None)',)",scipy,1.1.0,scipy.linalg.special_matrices.tri,linalg.special_matrices,tri,"Python Library Documentation: function tri in module scipy.linalg.special_matrices

tri(N, M=None, k=0, dtype=None)
    Construct (N, M) matrix filled with ones at and below the k-th diagonal.
    
    The matrix has A[i,j] == 1 for i <= j + k
    
    Parameters
    ----------
    N : int
        The size of the first dimension of the matrix.
    M : int or None, optional
        The size of the second dimension of the matrix. If `M` is None,
        `M = N` is assumed.
    k : int, optional
        Number of subdiagonal below which matrix is filled with ones.
        `k` = 0 is the main diagonal, `k` < 0 subdiagonal and `k` > 0
        superdiagonal.
    dtype : dtype, optional
        Data type of the matrix.
    
    Returns
    -------
    tri : (N, M) ndarray
        Tri matrix.
    
    Examples
    --------
    >>> from scipy.linalg import tri
    >>> tri(3, 5, 2, dtype=int)
    array([[1, 1, 1, 0, 0],
           [1, 1, 1, 1, 0],
           [1, 1, 1, 1, 1]])
    >>> tri(3, 5, -1, dtype=int)
    array([[0, 0, 0, 0, 0],
           [1, 0, 0, 0, 0],
           [1, 1, 0, 0, 0]])
",function,"('N', 'M', 'k', 'dtype')","(nan, None, 0, None)","(nan, 'NoneType', 'int', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(N, M=None, k=0, dtype=None)',)"
scipy,1.1.0,scipy.linalg.special_matrices.tril,linalg.special_matrices,tril,"Python Library Documentation: function tril in module scipy.linalg.special_matrices

tril(m, k=0)
    Make a copy of a matrix with elements above the k-th diagonal zeroed.
    
    Parameters
    ----------
    m : array_like
        Matrix whose elements to return
    k : int, optional
        Diagonal above which to zero elements.
        `k` == 0 is the main diagonal, `k` < 0 subdiagonal and
        `k` > 0 superdiagonal.
    
    Returns
    -------
    tril : ndarray
        Return is the same shape and type as `m`.
    
    Examples
    --------
    >>> from scipy.linalg import tril
    >>> tril([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
    array([[ 0,  0,  0],
           [ 4,  0,  0],
           [ 7,  8,  0],
           [10, 11, 12]])
",function,"('(m, k=0)',)",scipy,1.1.0,scipy.linalg.special_matrices.tril,linalg.special_matrices,tril,"Python Library Documentation: function tril in module scipy.linalg.special_matrices

tril(m, k=0)
    Make a copy of a matrix with elements above the k-th diagonal zeroed.
    
    Parameters
    ----------
    m : array_like
        Matrix whose elements to return
    k : int, optional
        Diagonal above which to zero elements.
        `k` == 0 is the main diagonal, `k` < 0 subdiagonal and
        `k` > 0 superdiagonal.
    
    Returns
    -------
    tril : ndarray
        Return is the same shape and type as `m`.
    
    Examples
    --------
    >>> from scipy.linalg import tril
    >>> tril([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
    array([[ 0,  0,  0],
           [ 4,  0,  0],
           [ 7,  8,  0],
           [10, 11, 12]])
",function,"('m', 'k')","(nan, 0)","(nan, 'int')","('arg_info', 'arg_info')","('(m, k=0)',)"
scipy,1.1.0,scipy.linalg.special_matrices.triu,linalg.special_matrices,triu,"Python Library Documentation: function triu in module scipy.linalg.special_matrices

triu(m, k=0)
    Make a copy of a matrix with elements below the k-th diagonal zeroed.
    
    Parameters
    ----------
    m : array_like
        Matrix whose elements to return
    k : int, optional
        Diagonal below which to zero elements.
        `k` == 0 is the main diagonal, `k` < 0 subdiagonal and
        `k` > 0 superdiagonal.
    
    Returns
    -------
    triu : ndarray
        Return matrix with zeroed elements below the k-th diagonal and has
        same shape and type as `m`.
    
    Examples
    --------
    >>> from scipy.linalg import triu
    >>> triu([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
    array([[ 1,  2,  3],
           [ 4,  5,  6],
           [ 0,  8,  9],
           [ 0,  0, 12]])
",function,"('(m, k=0)',)",scipy,1.1.0,scipy.linalg.special_matrices.triu,linalg.special_matrices,triu,"Python Library Documentation: function triu in module scipy.linalg.special_matrices

triu(m, k=0)
    Make a copy of a matrix with elements below the k-th diagonal zeroed.
    
    Parameters
    ----------
    m : array_like
        Matrix whose elements to return
    k : int, optional
        Diagonal below which to zero elements.
        `k` == 0 is the main diagonal, `k` < 0 subdiagonal and
        `k` > 0 superdiagonal.
    
    Returns
    -------
    triu : ndarray
        Return matrix with zeroed elements below the k-th diagonal and has
        same shape and type as `m`.
    
    Examples
    --------
    >>> from scipy.linalg import triu
    >>> triu([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
    array([[ 1,  2,  3],
           [ 4,  5,  6],
           [ 0,  8,  9],
           [ 0,  0, 12]])
",function,"('m', 'k')","(nan, 0)","(nan, 'int')","('arg_info', 'arg_info')","('(m, k=0)',)"
scipy,1.1.0,scipy.linalg.special_matrices.xrange,linalg.special_matrices,range,"Python Library Documentation: class range in module builtins

class range(object)
 |  range(stop) -> range object
 |  range(start, stop[, step]) -> range object
 |  
 |  Return an object that produces a sequence of integers from start (inclusive)
 |  to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.
 |  start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.
 |  These are exactly the valid indices for a list of 4 elements.
 |  When step is given, it specifies the increment (or decrement).
 |  
 |  Methods defined here:
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(...)
 |      Return a reverse iterator.
 |  
 |  count(...)
 |      rangeobject.count(value) -> integer -- return number of occurrences of value
 |  
 |  index(...)
 |      rangeobject.index(value, [start, [stop]]) -> integer -- return index of value.
 |      Raise ValueError if the value is not present.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  start
 |  
 |  step
 |  
 |  stop
",class,"('(self, /, *args, **kwargs)',)",scipy,1.1.0,scipy.linalg.special_matrices.xrange,linalg.special_matrices,range,"Python Library Documentation: class range in module builtins

class range(object)
 |  range(stop) -> range object
 |  range(start, stop[, step]) -> range object
 |  
 |  Return an object that produces a sequence of integers from start (inclusive)
 |  to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.
 |  start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.
 |  These are exactly the valid indices for a list of 4 elements.
 |  When step is given, it specifies the increment (or decrement).
 |  
 |  Methods defined here:
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(...)
 |      Return a reverse iterator.
 |  
 |  count(...)
 |      rangeobject.count(value) -> integer -- return number of occurrences of value
 |  
 |  index(...)
 |      rangeobject.index(value, [start, [stop]]) -> integer -- return index of value.
 |      Raise ValueError if the value is not present.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  start
 |  
 |  step
 |  
 |  stop
",class,"('self',)","(nan,)","(nan,)","('arg_info',)","('(self, /, *args, **kwargs)',)"
scipy,1.1.0,scipy.linalg.sqrtm,linalg,sqrtm,"Python Library Documentation: function sqrtm in module scipy.linalg._matfuncs_sqrtm

sqrtm(A, disp=True, blocksize=64)
    Matrix square root.
    
    Parameters
    ----------
    A : (N, N) array_like
        Matrix whose square root to evaluate
    disp : bool, optional
        Print warning if error in the result is estimated large
        instead of returning estimated error. (Default: True)
    blocksize : integer, optional
        If the blocksize is not degenerate with respect to the
        size of the input array, then use a blocked algorithm. (Default: 64)
    
    Returns
    -------
    sqrtm : (N, N) ndarray
        Value of the sqrt function at `A`
    
    errest : float
        (if disp == False)
    
        Frobenius norm of the estimated error, ||err||_F / ||A||_F
    
    References
    ----------
    .. [1] Edvin Deadman, Nicholas J. Higham, Rui Ralha (2013)
           ""Blocked Schur Algorithms for Computing the Matrix Square Root,
           Lecture Notes in Computer Science, 7782. pp. 171-182.
    
    Examples
    --------
    >>> from scipy.linalg import sqrtm
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> r = sqrtm(a)
    >>> r
    array([[ 0.75592895,  1.13389342],
           [ 0.37796447,  1.88982237]])
    >>> r.dot(r)
    array([[ 1.,  3.],
           [ 1.,  4.]])
",function,"('(A, disp=True, blocksize=64)',)",scipy,1.1.0,scipy.linalg.sqrtm,linalg,sqrtm,"Python Library Documentation: function sqrtm in module scipy.linalg._matfuncs_sqrtm

sqrtm(A, disp=True, blocksize=64)
    Matrix square root.
    
    Parameters
    ----------
    A : (N, N) array_like
        Matrix whose square root to evaluate
    disp : bool, optional
        Print warning if error in the result is estimated large
        instead of returning estimated error. (Default: True)
    blocksize : integer, optional
        If the blocksize is not degenerate with respect to the
        size of the input array, then use a blocked algorithm. (Default: 64)
    
    Returns
    -------
    sqrtm : (N, N) ndarray
        Value of the sqrt function at `A`
    
    errest : float
        (if disp == False)
    
        Frobenius norm of the estimated error, ||err||_F / ||A||_F
    
    References
    ----------
    .. [1] Edvin Deadman, Nicholas J. Higham, Rui Ralha (2013)
           ""Blocked Schur Algorithms for Computing the Matrix Square Root,
           Lecture Notes in Computer Science, 7782. pp. 171-182.
    
    Examples
    --------
    >>> from scipy.linalg import sqrtm
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> r = sqrtm(a)
    >>> r
    array([[ 0.75592895,  1.13389342],
           [ 0.37796447,  1.88982237]])
    >>> r.dot(r)
    array([[ 1.,  3.],
           [ 1.,  4.]])
",function,"('A', 'disp', 'blocksize')","(nan, True, 64)","(nan, 'bool', 'int')","('arg_info', 'arg_info', 'arg_info')","('(A, disp=True, blocksize=64)',)"
scipy,1.1.0,scipy.linalg.subspace_angles,linalg,subspace_angles,"Python Library Documentation: function subspace_angles in module scipy.linalg.decomp_svd

subspace_angles(A, B)
    Compute the subspace angles between two matrices.
    
    Parameters
    ----------
    A : (M, N) array_like
        The first input array.
    B : (M, K) array_like
        The second input array.
    
    Returns
    -------
    angles : ndarray, shape (min(N, K),)
        The subspace angles between the column spaces of `A` and `B`.
    
    See Also
    --------
    orth
    svd
    
    Notes
    -----
    This computes the subspace angles according to the formula
    provided in [1]_. For equivalence with MATLAB and Octave behavior,
    use ``angles[0]``.
    
    .. versionadded:: 1.0
    
    References
    ----------
    .. [1] Knyazev A, Argentati M (2002) Principal Angles between Subspaces
           in an A-Based Scalar Product: Algorithms and Perturbation
           Estimates. SIAM J. Sci. Comput. 23:2008-2040.
    
    Examples
    --------
    A Hadamard matrix, which has orthogonal columns, so we expect that
    the suspace angle to be :math:`\frac{\pi}{2}`:
    
    >>> from scipy.linalg import hadamard, subspace_angles
    >>> H = hadamard(4)
    >>> print(H)
    [[ 1  1  1  1]
     [ 1 -1  1 -1]
     [ 1  1 -1 -1]
     [ 1 -1 -1  1]]
    >>> np.rad2deg(subspace_angles(H[:, :2], H[:, 2:]))
    array([ 90.,  90.])
    
    And the subspace angle of a matrix to itself should be zero:
    
    >>> subspace_angles(H[:, :2], H[:, :2]) <= 2 * np.finfo(float).eps
    array([ True,  True], dtype=bool)
    
    The angles between non-orthogonal subspaces are in between these extremes:
    
    >>> x = np.random.RandomState(0).randn(4, 3)
    >>> np.rad2deg(subspace_angles(x[:, :2], x[:, [2]]))
    array([ 55.832])
",function,"('(A, B)',)",scipy,1.1.0,scipy.linalg.subspace_angles,linalg,subspace_angles,"Python Library Documentation: function subspace_angles in module scipy.linalg.decomp_svd

subspace_angles(A, B)
    Compute the subspace angles between two matrices.
    
    Parameters
    ----------
    A : (M, N) array_like
        The first input array.
    B : (M, K) array_like
        The second input array.
    
    Returns
    -------
    angles : ndarray, shape (min(N, K),)
        The subspace angles between the column spaces of `A` and `B`.
    
    See Also
    --------
    orth
    svd
    
    Notes
    -----
    This computes the subspace angles according to the formula
    provided in [1]_. For equivalence with MATLAB and Octave behavior,
    use ``angles[0]``.
    
    .. versionadded:: 1.0
    
    References
    ----------
    .. [1] Knyazev A, Argentati M (2002) Principal Angles between Subspaces
           in an A-Based Scalar Product: Algorithms and Perturbation
           Estimates. SIAM J. Sci. Comput. 23:2008-2040.
    
    Examples
    --------
    A Hadamard matrix, which has orthogonal columns, so we expect that
    the suspace angle to be :math:`\frac{\pi}{2}`:
    
    >>> from scipy.linalg import hadamard, subspace_angles
    >>> H = hadamard(4)
    >>> print(H)
    [[ 1  1  1  1]
     [ 1 -1  1 -1]
     [ 1  1 -1 -1]
     [ 1 -1 -1  1]]
    >>> np.rad2deg(subspace_angles(H[:, :2], H[:, 2:]))
    array([ 90.,  90.])
    
    And the subspace angle of a matrix to itself should be zero:
    
    >>> subspace_angles(H[:, :2], H[:, :2]) <= 2 * np.finfo(float).eps
    array([ True,  True], dtype=bool)
    
    The angles between non-orthogonal subspaces are in between these extremes:
    
    >>> x = np.random.RandomState(0).randn(4, 3)
    >>> np.rad2deg(subspace_angles(x[:, :2], x[:, [2]]))
    array([ 55.832])
",function,"('A', 'B')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(A, B)',)"
scipy,1.1.0,scipy.linalg.svd,linalg,svd,"Python Library Documentation: function svd in module scipy.linalg.decomp_svd

svd(a, full_matrices=True, compute_uv=True, overwrite_a=False, check_finite=True, lapack_driver='gesdd')
    Singular Value Decomposition.
    
    Factorizes the matrix `a` into two unitary matrices ``U`` and ``Vh``, and
    a 1-D array ``s`` of singular values (real, non-negative) such that
    ``a == U @ S @ Vh``, where ``S`` is a suitably shaped matrix of zeros with
    main diagonal ``s``.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to decompose.
    full_matrices : bool, optional
        If True (default), `U` and `Vh` are of shape ``(M, M)``, ``(N, N)``.
        If False, the shapes are ``(M, K)`` and ``(K, N)``, where
        ``K = min(M, N)``.
    compute_uv : bool, optional
        Whether to compute also ``U`` and ``Vh`` in addition to ``s``.
        Default is True.
    overwrite_a : bool, optional
        Whether to overwrite `a`; may improve performance.
        Default is False.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    lapack_driver : {'gesdd', 'gesvd'}, optional
        Whether to use the more efficient divide-and-conquer approach
        (``'gesdd'``) or general rectangular approach (``'gesvd'``)
        to compute the SVD. MATLAB and Octave use the ``'gesvd'`` approach.
        Default is ``'gesdd'``.
    
        .. versionadded:: 0.18
    
    Returns
    -------
    U : ndarray
        Unitary matrix having left singular vectors as columns.
        Of shape ``(M, M)`` or ``(M, K)``, depending on `full_matrices`.
    s : ndarray
        The singular values, sorted in non-increasing order.
        Of shape (K,), with ``K = min(M, N)``.
    Vh : ndarray
        Unitary matrix having right singular vectors as rows.
        Of shape ``(N, N)`` or ``(K, N)`` depending on `full_matrices`.
    
    For ``compute_uv=False``, only ``s`` is returned.
    
    Raises
    ------
    LinAlgError
        If SVD computation does not converge.
    
    See also
    --------
    svdvals : Compute singular values of a matrix.
    diagsvd : Construct the Sigma matrix, given the vector s.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> m, n = 9, 6
    >>> a = np.random.randn(m, n) + 1.j*np.random.randn(m, n)
    >>> U, s, Vh = linalg.svd(a)
    >>> U.shape,  s.shape, Vh.shape
    ((9, 9), (6,), (6, 6))
    
    Reconstruct the original matrix from the decomposition:
    
    >>> sigma = np.zeros((m, n))
    >>> for i in range(min(m, n)):
    ...     sigma[i, i] = s[i]
    >>> a1 = np.dot(U, np.dot(sigma, Vh))
    >>> np.allclose(a, a1)
    True
    
    Alternatively, use ``full_matrices=False`` (notice that the shape of
    ``U`` is then ``(m, n)`` instead of ``(m, m)``):
    
    >>> U, s, Vh = linalg.svd(a, full_matrices=False)
    >>> U.shape, s.shape, Vh.shape
    ((9, 6), (6,), (6, 6))
    >>> S = np.diag(s)
    >>> np.allclose(a, np.dot(U, np.dot(S, Vh)))
    True
    
    >>> s2 = linalg.svd(a, compute_uv=False)
    >>> np.allclose(s, s2)
    True
",function,"(""(a, full_matrices=True, compute_uv=True, overwrite_a=False, check_finite=True, lapack_driver='gesdd')"",)",scipy,1.1.0,scipy.linalg.svd,linalg,svd,"Python Library Documentation: function svd in module scipy.linalg.decomp_svd

svd(a, full_matrices=True, compute_uv=True, overwrite_a=False, check_finite=True, lapack_driver='gesdd')
    Singular Value Decomposition.
    
    Factorizes the matrix `a` into two unitary matrices ``U`` and ``Vh``, and
    a 1-D array ``s`` of singular values (real, non-negative) such that
    ``a == U @ S @ Vh``, where ``S`` is a suitably shaped matrix of zeros with
    main diagonal ``s``.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to decompose.
    full_matrices : bool, optional
        If True (default), `U` and `Vh` are of shape ``(M, M)``, ``(N, N)``.
        If False, the shapes are ``(M, K)`` and ``(K, N)``, where
        ``K = min(M, N)``.
    compute_uv : bool, optional
        Whether to compute also ``U`` and ``Vh`` in addition to ``s``.
        Default is True.
    overwrite_a : bool, optional
        Whether to overwrite `a`; may improve performance.
        Default is False.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    lapack_driver : {'gesdd', 'gesvd'}, optional
        Whether to use the more efficient divide-and-conquer approach
        (``'gesdd'``) or general rectangular approach (``'gesvd'``)
        to compute the SVD. MATLAB and Octave use the ``'gesvd'`` approach.
        Default is ``'gesdd'``.
    
        .. versionadded:: 0.18
    
    Returns
    -------
    U : ndarray
        Unitary matrix having left singular vectors as columns.
        Of shape ``(M, M)`` or ``(M, K)``, depending on `full_matrices`.
    s : ndarray
        The singular values, sorted in non-increasing order.
        Of shape (K,), with ``K = min(M, N)``.
    Vh : ndarray
        Unitary matrix having right singular vectors as rows.
        Of shape ``(N, N)`` or ``(K, N)`` depending on `full_matrices`.
    
    For ``compute_uv=False``, only ``s`` is returned.
    
    Raises
    ------
    LinAlgError
        If SVD computation does not converge.
    
    See also
    --------
    svdvals : Compute singular values of a matrix.
    diagsvd : Construct the Sigma matrix, given the vector s.
    
    Examples
    --------
    >>> from scipy import linalg
    >>> m, n = 9, 6
    >>> a = np.random.randn(m, n) + 1.j*np.random.randn(m, n)
    >>> U, s, Vh = linalg.svd(a)
    >>> U.shape,  s.shape, Vh.shape
    ((9, 9), (6,), (6, 6))
    
    Reconstruct the original matrix from the decomposition:
    
    >>> sigma = np.zeros((m, n))
    >>> for i in range(min(m, n)):
    ...     sigma[i, i] = s[i]
    >>> a1 = np.dot(U, np.dot(sigma, Vh))
    >>> np.allclose(a, a1)
    True
    
    Alternatively, use ``full_matrices=False`` (notice that the shape of
    ``U`` is then ``(m, n)`` instead of ``(m, m)``):
    
    >>> U, s, Vh = linalg.svd(a, full_matrices=False)
    >>> U.shape, s.shape, Vh.shape
    ((9, 6), (6,), (6, 6))
    >>> S = np.diag(s)
    >>> np.allclose(a, np.dot(U, np.dot(S, Vh)))
    True
    
    >>> s2 = linalg.svd(a, compute_uv=False)
    >>> np.allclose(s, s2)
    True
",function,"('a', 'full_matrices', 'compute_uv', 'overwrite_a', 'check_finite', 'lapack_driver')","(nan, True, True, False, True, 'gesdd')","(nan, 'bool', 'bool', 'bool', 'bool', 'str')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(a, full_matrices=True, compute_uv=True, overwrite_a=False, check_finite=True, lapack_driver='gesdd')"",)"
scipy,1.1.0,scipy.linalg.svdvals,linalg,svdvals,"Python Library Documentation: function svdvals in module scipy.linalg.decomp_svd

svdvals(a, overwrite_a=False, check_finite=True)
    Compute singular values of a matrix.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to decompose.
    overwrite_a : bool, optional
        Whether to overwrite `a`; may improve performance.
        Default is False.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    s : (min(M, N),) ndarray
        The singular values, sorted in decreasing order.
    
    Raises
    ------
    LinAlgError
        If SVD computation does not converge.
    
    Notes
    -----
    ``svdvals(a)`` only differs from ``svd(a, compute_uv=False)`` by its
    handling of the edge case of empty ``a``, where it returns an
    empty sequence:
    
    >>> a = np.empty((0, 2))
    >>> from scipy.linalg import svdvals
    >>> svdvals(a)
    array([], dtype=float64)
    
    See Also
    --------
    svd : Compute the full singular value decomposition of a matrix.
    diagsvd : Construct the Sigma matrix, given the vector s.
    
    Examples
    --------
    >>> from scipy.linalg import svdvals
    >>> m = np.array([[1.0, 0.0],
    ...               [2.0, 3.0],
    ...               [1.0, 1.0],
    ...               [0.0, 2.0],
    ...               [1.0, 0.0]])
    >>> svdvals(m)
    array([ 4.28091555,  1.63516424])
    
    We can verify the maximum singular value of `m` by computing the maximum
    length of `m.dot(u)` over all the unit vectors `u` in the (x,y) plane.
    We approximate ""all"" the unit vectors with a large sample.  Because
    of linearity, we only need the unit vectors with angles in [0, pi].
    
    >>> t = np.linspace(0, np.pi, 2000)
    >>> u = np.array([np.cos(t), np.sin(t)])
    >>> np.linalg.norm(m.dot(u), axis=0).max()
    4.2809152422538475
    
    `p` is a projection matrix with rank 1.  With exact arithmetic,
    its singular values would be [1, 0, 0, 0].
    
    >>> v = np.array([0.1, 0.3, 0.9, 0.3])
    >>> p = np.outer(v, v)
    >>> svdvals(p)
    array([  1.00000000e+00,   2.02021698e-17,   1.56692500e-17,
             8.15115104e-34])
    
    The singular values of an orthogonal matrix are all 1.  Here we
    create a random orthogonal matrix by using the `rvs()` method of
    `scipy.stats.ortho_group`.
    
    >>> from scipy.stats import ortho_group
    >>> np.random.seed(123)
    >>> orth = ortho_group.rvs(4)
    >>> svdvals(orth)
    array([ 1.,  1.,  1.,  1.])
",function,"('(a, overwrite_a=False, check_finite=True)',)",scipy,1.1.0,scipy.linalg.svdvals,linalg,svdvals,"Python Library Documentation: function svdvals in module scipy.linalg.decomp_svd

svdvals(a, overwrite_a=False, check_finite=True)
    Compute singular values of a matrix.
    
    Parameters
    ----------
    a : (M, N) array_like
        Matrix to decompose.
    overwrite_a : bool, optional
        Whether to overwrite `a`; may improve performance.
        Default is False.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
    
    Returns
    -------
    s : (min(M, N),) ndarray
        The singular values, sorted in decreasing order.
    
    Raises
    ------
    LinAlgError
        If SVD computation does not converge.
    
    Notes
    -----
    ``svdvals(a)`` only differs from ``svd(a, compute_uv=False)`` by its
    handling of the edge case of empty ``a``, where it returns an
    empty sequence:
    
    >>> a = np.empty((0, 2))
    >>> from scipy.linalg import svdvals
    >>> svdvals(a)
    array([], dtype=float64)
    
    See Also
    --------
    svd : Compute the full singular value decomposition of a matrix.
    diagsvd : Construct the Sigma matrix, given the vector s.
    
    Examples
    --------
    >>> from scipy.linalg import svdvals
    >>> m = np.array([[1.0, 0.0],
    ...               [2.0, 3.0],
    ...               [1.0, 1.0],
    ...               [0.0, 2.0],
    ...               [1.0, 0.0]])
    >>> svdvals(m)
    array([ 4.28091555,  1.63516424])
    
    We can verify the maximum singular value of `m` by computing the maximum
    length of `m.dot(u)` over all the unit vectors `u` in the (x,y) plane.
    We approximate ""all"" the unit vectors with a large sample.  Because
    of linearity, we only need the unit vectors with angles in [0, pi].
    
    >>> t = np.linspace(0, np.pi, 2000)
    >>> u = np.array([np.cos(t), np.sin(t)])
    >>> np.linalg.norm(m.dot(u), axis=0).max()
    4.2809152422538475
    
    `p` is a projection matrix with rank 1.  With exact arithmetic,
    its singular values would be [1, 0, 0, 0].
    
    >>> v = np.array([0.1, 0.3, 0.9, 0.3])
    >>> p = np.outer(v, v)
    >>> svdvals(p)
    array([  1.00000000e+00,   2.02021698e-17,   1.56692500e-17,
             8.15115104e-34])
    
    The singular values of an orthogonal matrix are all 1.  Here we
    create a random orthogonal matrix by using the `rvs()` method of
    `scipy.stats.ortho_group`.
    
    >>> from scipy.stats import ortho_group
    >>> np.random.seed(123)
    >>> orth = ortho_group.rvs(4)
    >>> svdvals(orth)
    array([ 1.,  1.,  1.,  1.])
",function,"('a', 'overwrite_a', 'check_finite')","(nan, False, True)","(nan, 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info')","('(a, overwrite_a=False, check_finite=True)',)"
scipy,1.1.0,scipy.linalg.tanhm,linalg,tanhm,"Python Library Documentation: function tanhm in module scipy.linalg.matfuncs

tanhm(A)
    Compute the hyperbolic matrix tangent.
    
    This routine uses expm to compute the matrix exponentials.
    
    Parameters
    ----------
    A : (N, N) array_like
        Input array
    
    Returns
    -------
    tanhm : (N, N) ndarray
        Hyperbolic matrix tangent of `A`
    
    Examples
    --------
    >>> from scipy.linalg import tanhm, sinhm, coshm
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> t = tanhm(a)
    >>> t
    array([[ 0.3428582 ,  0.51987926],
           [ 0.17329309,  0.86273746]])
    
    Verify tanhm(a) = sinhm(a).dot(inv(coshm(a)))
    
    >>> s = sinhm(a)
    >>> c = coshm(a)
    >>> t - s.dot(np.linalg.inv(c))
    array([[  2.72004641e-15,   4.55191440e-15],
           [  0.00000000e+00,  -5.55111512e-16]])
",function,"('(A)',)",scipy,1.1.0,scipy.linalg.tanhm,linalg,tanhm,"Python Library Documentation: function tanhm in module scipy.linalg.matfuncs

tanhm(A)
    Compute the hyperbolic matrix tangent.
    
    This routine uses expm to compute the matrix exponentials.
    
    Parameters
    ----------
    A : (N, N) array_like
        Input array
    
    Returns
    -------
    tanhm : (N, N) ndarray
        Hyperbolic matrix tangent of `A`
    
    Examples
    --------
    >>> from scipy.linalg import tanhm, sinhm, coshm
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> t = tanhm(a)
    >>> t
    array([[ 0.3428582 ,  0.51987926],
           [ 0.17329309,  0.86273746]])
    
    Verify tanhm(a) = sinhm(a).dot(inv(coshm(a)))
    
    >>> s = sinhm(a)
    >>> c = coshm(a)
    >>> t - s.dot(np.linalg.inv(c))
    array([[  2.72004641e-15,   4.55191440e-15],
           [  0.00000000e+00,  -5.55111512e-16]])
",function,"('A',)","(nan,)","(nan,)","('arg_info',)","('(A)',)"
scipy,1.1.0,scipy.linalg.tanm,linalg,tanm,"Python Library Documentation: function tanm in module scipy.linalg.matfuncs

tanm(A)
    Compute the matrix tangent.
    
    This routine uses expm to compute the matrix exponentials.
    
    Parameters
    ----------
    A : (N, N) array_like
        Input array.
    
    Returns
    -------
    tanm : (N, N) ndarray
        Matrix tangent of `A`
    
    Examples
    --------
    >>> from scipy.linalg import tanm, sinm, cosm
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> t = tanm(a)
    >>> t
    array([[ -2.00876993,  -8.41880636],
           [ -2.80626879, -10.42757629]])
    
    Verify tanm(a) = sinm(a).dot(inv(cosm(a)))
    
    >>> s = sinm(a)
    >>> c = cosm(a)
    >>> s.dot(np.linalg.inv(c))
    array([[ -2.00876993,  -8.41880636],
           [ -2.80626879, -10.42757629]])
",function,"('(A)',)",scipy,1.1.0,scipy.linalg.tanm,linalg,tanm,"Python Library Documentation: function tanm in module scipy.linalg.matfuncs

tanm(A)
    Compute the matrix tangent.
    
    This routine uses expm to compute the matrix exponentials.
    
    Parameters
    ----------
    A : (N, N) array_like
        Input array.
    
    Returns
    -------
    tanm : (N, N) ndarray
        Matrix tangent of `A`
    
    Examples
    --------
    >>> from scipy.linalg import tanm, sinm, cosm
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> t = tanm(a)
    >>> t
    array([[ -2.00876993,  -8.41880636],
           [ -2.80626879, -10.42757629]])
    
    Verify tanm(a) = sinm(a).dot(inv(cosm(a)))
    
    >>> s = sinm(a)
    >>> c = cosm(a)
    >>> s.dot(np.linalg.inv(c))
    array([[ -2.00876993,  -8.41880636],
           [ -2.80626879, -10.42757629]])
",function,"('A',)","(nan,)","(nan,)","('arg_info',)","('(A)',)"
scipy,1.1.0,scipy.linalg.toeplitz,linalg,toeplitz,"Python Library Documentation: function toeplitz in module scipy.linalg.special_matrices

toeplitz(c, r=None)
    Construct a Toeplitz matrix.
    
    The Toeplitz matrix has constant diagonals, with c as its first column
    and r as its first row.  If r is not given, ``r == conjugate(c)`` is
    assumed.
    
    Parameters
    ----------
    c : array_like
        First column of the matrix.  Whatever the actual shape of `c`, it
        will be converted to a 1-D array.
    r : array_like, optional
        First row of the matrix. If None, ``r = conjugate(c)`` is assumed;
        in this case, if c[0] is real, the result is a Hermitian matrix.
        r[0] is ignored; the first row of the returned matrix is
        ``[c[0], r[1:]]``.  Whatever the actual shape of `r`, it will be
        converted to a 1-D array.
    
    Returns
    -------
    A : (len(c), len(r)) ndarray
        The Toeplitz matrix. Dtype is the same as ``(c[0] + r[0]).dtype``.
    
    See Also
    --------
    circulant : circulant matrix
    hankel : Hankel matrix
    solve_toeplitz : Solve a Toeplitz system.
    
    Notes
    -----
    The behavior when `c` or `r` is a scalar, or when `c` is complex and
    `r` is None, was changed in version 0.8.0.  The behavior in previous
    versions was undocumented and is no longer supported.
    
    Examples
    --------
    >>> from scipy.linalg import toeplitz
    >>> toeplitz([1,2,3], [1,4,5,6])
    array([[1, 4, 5, 6],
           [2, 1, 4, 5],
           [3, 2, 1, 4]])
    >>> toeplitz([1.0, 2+3j, 4-1j])
    array([[ 1.+0.j,  2.-3.j,  4.+1.j],
           [ 2.+3.j,  1.+0.j,  2.-3.j],
           [ 4.-1.j,  2.+3.j,  1.+0.j]])
",function,"('(c, r=None)',)",scipy,1.1.0,scipy.linalg.toeplitz,linalg,toeplitz,"Python Library Documentation: function toeplitz in module scipy.linalg.special_matrices

toeplitz(c, r=None)
    Construct a Toeplitz matrix.
    
    The Toeplitz matrix has constant diagonals, with c as its first column
    and r as its first row.  If r is not given, ``r == conjugate(c)`` is
    assumed.
    
    Parameters
    ----------
    c : array_like
        First column of the matrix.  Whatever the actual shape of `c`, it
        will be converted to a 1-D array.
    r : array_like, optional
        First row of the matrix. If None, ``r = conjugate(c)`` is assumed;
        in this case, if c[0] is real, the result is a Hermitian matrix.
        r[0] is ignored; the first row of the returned matrix is
        ``[c[0], r[1:]]``.  Whatever the actual shape of `r`, it will be
        converted to a 1-D array.
    
    Returns
    -------
    A : (len(c), len(r)) ndarray
        The Toeplitz matrix. Dtype is the same as ``(c[0] + r[0]).dtype``.
    
    See Also
    --------
    circulant : circulant matrix
    hankel : Hankel matrix
    solve_toeplitz : Solve a Toeplitz system.
    
    Notes
    -----
    The behavior when `c` or `r` is a scalar, or when `c` is complex and
    `r` is None, was changed in version 0.8.0.  The behavior in previous
    versions was undocumented and is no longer supported.
    
    Examples
    --------
    >>> from scipy.linalg import toeplitz
    >>> toeplitz([1,2,3], [1,4,5,6])
    array([[1, 4, 5, 6],
           [2, 1, 4, 5],
           [3, 2, 1, 4]])
    >>> toeplitz([1.0, 2+3j, 4-1j])
    array([[ 1.+0.j,  2.-3.j,  4.+1.j],
           [ 2.+3.j,  1.+0.j,  2.-3.j],
           [ 4.-1.j,  2.+3.j,  1.+0.j]])
",function,"('c', 'r')","(nan, None)","(nan, 'NoneType')","('arg_info', 'arg_info')","('(c, r=None)',)"
scipy,1.1.0,scipy.linalg.tri,linalg,tri,"Python Library Documentation: function tri in module scipy.linalg.special_matrices

tri(N, M=None, k=0, dtype=None)
    Construct (N, M) matrix filled with ones at and below the k-th diagonal.
    
    The matrix has A[i,j] == 1 for i <= j + k
    
    Parameters
    ----------
    N : int
        The size of the first dimension of the matrix.
    M : int or None, optional
        The size of the second dimension of the matrix. If `M` is None,
        `M = N` is assumed.
    k : int, optional
        Number of subdiagonal below which matrix is filled with ones.
        `k` = 0 is the main diagonal, `k` < 0 subdiagonal and `k` > 0
        superdiagonal.
    dtype : dtype, optional
        Data type of the matrix.
    
    Returns
    -------
    tri : (N, M) ndarray
        Tri matrix.
    
    Examples
    --------
    >>> from scipy.linalg import tri
    >>> tri(3, 5, 2, dtype=int)
    array([[1, 1, 1, 0, 0],
           [1, 1, 1, 1, 0],
           [1, 1, 1, 1, 1]])
    >>> tri(3, 5, -1, dtype=int)
    array([[0, 0, 0, 0, 0],
           [1, 0, 0, 0, 0],
           [1, 1, 0, 0, 0]])
",function,"('(N, M=None, k=0, dtype=None)',)",scipy,1.1.0,scipy.linalg.tri,linalg,tri,"Python Library Documentation: function tri in module scipy.linalg.special_matrices

tri(N, M=None, k=0, dtype=None)
    Construct (N, M) matrix filled with ones at and below the k-th diagonal.
    
    The matrix has A[i,j] == 1 for i <= j + k
    
    Parameters
    ----------
    N : int
        The size of the first dimension of the matrix.
    M : int or None, optional
        The size of the second dimension of the matrix. If `M` is None,
        `M = N` is assumed.
    k : int, optional
        Number of subdiagonal below which matrix is filled with ones.
        `k` = 0 is the main diagonal, `k` < 0 subdiagonal and `k` > 0
        superdiagonal.
    dtype : dtype, optional
        Data type of the matrix.
    
    Returns
    -------
    tri : (N, M) ndarray
        Tri matrix.
    
    Examples
    --------
    >>> from scipy.linalg import tri
    >>> tri(3, 5, 2, dtype=int)
    array([[1, 1, 1, 0, 0],
           [1, 1, 1, 1, 0],
           [1, 1, 1, 1, 1]])
    >>> tri(3, 5, -1, dtype=int)
    array([[0, 0, 0, 0, 0],
           [1, 0, 0, 0, 0],
           [1, 1, 0, 0, 0]])
",function,"('N', 'M', 'k', 'dtype')","(nan, None, 0, None)","(nan, 'NoneType', 'int', 'NoneType')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(N, M=None, k=0, dtype=None)',)"
scipy,1.1.0,scipy.linalg.tril,linalg,tril,"Python Library Documentation: function tril in module scipy.linalg.special_matrices

tril(m, k=0)
    Make a copy of a matrix with elements above the k-th diagonal zeroed.
    
    Parameters
    ----------
    m : array_like
        Matrix whose elements to return
    k : int, optional
        Diagonal above which to zero elements.
        `k` == 0 is the main diagonal, `k` < 0 subdiagonal and
        `k` > 0 superdiagonal.
    
    Returns
    -------
    tril : ndarray
        Return is the same shape and type as `m`.
    
    Examples
    --------
    >>> from scipy.linalg import tril
    >>> tril([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
    array([[ 0,  0,  0],
           [ 4,  0,  0],
           [ 7,  8,  0],
           [10, 11, 12]])
",function,"('(m, k=0)',)",scipy,1.1.0,scipy.linalg.tril,linalg,tril,"Python Library Documentation: function tril in module scipy.linalg.special_matrices

tril(m, k=0)
    Make a copy of a matrix with elements above the k-th diagonal zeroed.
    
    Parameters
    ----------
    m : array_like
        Matrix whose elements to return
    k : int, optional
        Diagonal above which to zero elements.
        `k` == 0 is the main diagonal, `k` < 0 subdiagonal and
        `k` > 0 superdiagonal.
    
    Returns
    -------
    tril : ndarray
        Return is the same shape and type as `m`.
    
    Examples
    --------
    >>> from scipy.linalg import tril
    >>> tril([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
    array([[ 0,  0,  0],
           [ 4,  0,  0],
           [ 7,  8,  0],
           [10, 11, 12]])
",function,"('m', 'k')","(nan, 0)","(nan, 'int')","('arg_info', 'arg_info')","('(m, k=0)',)"
scipy,1.1.0,scipy.linalg.triu,linalg,triu,"Python Library Documentation: function triu in module scipy.linalg.special_matrices

triu(m, k=0)
    Make a copy of a matrix with elements below the k-th diagonal zeroed.
    
    Parameters
    ----------
    m : array_like
        Matrix whose elements to return
    k : int, optional
        Diagonal below which to zero elements.
        `k` == 0 is the main diagonal, `k` < 0 subdiagonal and
        `k` > 0 superdiagonal.
    
    Returns
    -------
    triu : ndarray
        Return matrix with zeroed elements below the k-th diagonal and has
        same shape and type as `m`.
    
    Examples
    --------
    >>> from scipy.linalg import triu
    >>> triu([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
    array([[ 1,  2,  3],
           [ 4,  5,  6],
           [ 0,  8,  9],
           [ 0,  0, 12]])
",function,"('(m, k=0)',)",scipy,1.1.0,scipy.linalg.triu,linalg,triu,"Python Library Documentation: function triu in module scipy.linalg.special_matrices

triu(m, k=0)
    Make a copy of a matrix with elements below the k-th diagonal zeroed.
    
    Parameters
    ----------
    m : array_like
        Matrix whose elements to return
    k : int, optional
        Diagonal below which to zero elements.
        `k` == 0 is the main diagonal, `k` < 0 subdiagonal and
        `k` > 0 superdiagonal.
    
    Returns
    -------
    triu : ndarray
        Return matrix with zeroed elements below the k-th diagonal and has
        same shape and type as `m`.
    
    Examples
    --------
    >>> from scipy.linalg import triu
    >>> triu([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
    array([[ 1,  2,  3],
           [ 4,  5,  6],
           [ 0,  8,  9],
           [ 0,  0, 12]])
",function,"('m', 'k')","(nan, 0)","(nan, 'int')","('arg_info', 'arg_info')","('(m, k=0)',)"
scipy,1.1.0,scipy.misc._comb,misc,comb,"Python Library Documentation: function comb in module scipy.special.basic

comb(N, k, exact=False, repetition=False)
    The number of combinations of N things taken k at a time.
    
    This is often expressed as ""N choose k"".
    
    Parameters
    ----------
    N : int, ndarray
        Number of things.
    k : int, ndarray
        Number of elements taken.
    exact : bool, optional
        If `exact` is False, then floating point precision is used, otherwise
        exact long integer is computed.
    repetition : bool, optional
        If `repetition` is True, then the number of combinations with
        repetition is computed.
    
    Returns
    -------
    val : int, float, ndarray
        The total number of combinations.
    
    See Also
    --------
    binom : Binomial coefficient ufunc
    
    Notes
    -----
    - Array arguments accepted only for exact=False case.
    - If k > N, N < 0, or k < 0, then a 0 is returned.
    
    Examples
    --------
    >>> from scipy.special import comb
    >>> k = np.array([3, 4])
    >>> n = np.array([10, 10])
    >>> comb(n, k, exact=False)
    array([ 120.,  210.])
    >>> comb(10, 3, exact=True)
    120L
    >>> comb(10, 3, exact=True, repetition=True)
    220L
",function,"('(N, k, exact=False, repetition=False)',)",scipy,1.1.0,scipy.misc._comb,misc,comb,"Python Library Documentation: function comb in module scipy.special.basic

comb(N, k, exact=False, repetition=False)
    The number of combinations of N things taken k at a time.
    
    This is often expressed as ""N choose k"".
    
    Parameters
    ----------
    N : int, ndarray
        Number of things.
    k : int, ndarray
        Number of elements taken.
    exact : bool, optional
        If `exact` is False, then floating point precision is used, otherwise
        exact long integer is computed.
    repetition : bool, optional
        If `repetition` is True, then the number of combinations with
        repetition is computed.
    
    Returns
    -------
    val : int, float, ndarray
        The total number of combinations.
    
    See Also
    --------
    binom : Binomial coefficient ufunc
    
    Notes
    -----
    - Array arguments accepted only for exact=False case.
    - If k > N, N < 0, or k < 0, then a 0 is returned.
    
    Examples
    --------
    >>> from scipy.special import comb
    >>> k = np.array([3, 4])
    >>> n = np.array([10, 10])
    >>> comb(n, k, exact=False)
    array([ 120.,  210.])
    >>> comb(10, 3, exact=True)
    120L
    >>> comb(10, 3, exact=True, repetition=True)
    220L
",function,"('N', 'k', 'exact', 'repetition')","(nan, nan, False, False)","(nan, nan, 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","('(N, k, exact=False, repetition=False)',)"
scipy,1.1.0,scipy.misc._fact,misc,factorial,"Python Library Documentation: function factorial in module scipy.special.basic

factorial(n, exact=False)
    The factorial of a number or array of numbers.
    
    The factorial of non-negative integer `n` is the product of all
    positive integers less than or equal to `n`::
    
        n! = n * (n - 1) * (n - 2) * ... * 1
    
    Parameters
    ----------
    n : int or array_like of ints
        Input values.  If ``n < 0``, the return value is 0.
    exact : bool, optional
        If True, calculate the answer exactly using long integer arithmetic.
        If False, result is approximated in floating point rapidly using the
        `gamma` function.
        Default is False.
    
    Returns
    -------
    nf : float or int or ndarray
        Factorial of `n`, as integer or float depending on `exact`.
    
    Notes
    -----
    For arrays with ``exact=True``, the factorial is computed only once, for
    the largest input, with each other result computed in the process.
    The output dtype is increased to ``int64`` or ``object`` if necessary.
    
    With ``exact=False`` the factorial is approximated using the gamma
    function:
    
    .. math:: n! = \Gamma(n+1)
    
    Examples
    --------
    >>> from scipy.special import factorial
    >>> arr = np.array([3, 4, 5])
    >>> factorial(arr, exact=False)
    array([   6.,   24.,  120.])
    >>> factorial(arr, exact=True)
    array([  6,  24, 120])
    >>> factorial(5, exact=True)
    120L
",function,"('(n, exact=False)',)",scipy,1.1.0,scipy.misc._fact,misc,factorial,"Python Library Documentation: function factorial in module scipy.special.basic

factorial(n, exact=False)
    The factorial of a number or array of numbers.
    
    The factorial of non-negative integer `n` is the product of all
    positive integers less than or equal to `n`::
    
        n! = n * (n - 1) * (n - 2) * ... * 1
    
    Parameters
    ----------
    n : int or array_like of ints
        Input values.  If ``n < 0``, the return value is 0.
    exact : bool, optional
        If True, calculate the answer exactly using long integer arithmetic.
        If False, result is approximated in floating point rapidly using the
        `gamma` function.
        Default is False.
    
    Returns
    -------
    nf : float or int or ndarray
        Factorial of `n`, as integer or float depending on `exact`.
    
    Notes
    -----
    For arrays with ``exact=True``, the factorial is computed only once, for
    the largest input, with each other result computed in the process.
    The output dtype is increased to ``int64`` or ``object`` if necessary.
    
    With ``exact=False`` the factorial is approximated using the gamma
    function:
    
    .. math:: n! = \Gamma(n+1)
    
    Examples
    --------
    >>> from scipy.special import factorial
    >>> arr = np.array([3, 4, 5])
    >>> factorial(arr, exact=False)
    array([   6.,   24.,  120.])
    >>> factorial(arr, exact=True)
    array([  6,  24, 120])
    >>> factorial(5, exact=True)
    120L
",function,"('n', 'exact')","(nan, False)","(nan, 'bool')","('arg_info', 'arg_info')","('(n, exact=False)',)"
scipy,1.1.0,scipy.misc._fact2,misc,factorial2,"Python Library Documentation: function factorial2 in module scipy.special.basic

factorial2(n, exact=False)
    Double factorial.
    
    This is the factorial with every second value skipped.  E.g., ``7!! = 7 * 5
    * 3 * 1``.  It can be approximated numerically as::
    
      n!! = special.gamma(n/2+1)*2**((m+1)/2)/sqrt(pi)  n odd
          = 2**(n/2) * (n/2)!                           n even
    
    Parameters
    ----------
    n : int or array_like
        Calculate ``n!!``.  Arrays are only supported with `exact` set
        to False.  If ``n < 0``, the return value is 0.
    exact : bool, optional
        The result can be approximated rapidly using the gamma-formula
        above (default).  If `exact` is set to True, calculate the
        answer exactly using integer arithmetic.
    
    Returns
    -------
    nff : float or int
        Double factorial of `n`, as an int or a float depending on
        `exact`.
    
    Examples
    --------
    >>> from scipy.special import factorial2
    >>> factorial2(7, exact=False)
    array(105.00000000000001)
    >>> factorial2(7, exact=True)
    105L
",function,"('(n, exact=False)',)",scipy,1.1.0,scipy.misc._fact2,misc,factorial2,"Python Library Documentation: function factorial2 in module scipy.special.basic

factorial2(n, exact=False)
    Double factorial.
    
    This is the factorial with every second value skipped.  E.g., ``7!! = 7 * 5
    * 3 * 1``.  It can be approximated numerically as::
    
      n!! = special.gamma(n/2+1)*2**((m+1)/2)/sqrt(pi)  n odd
          = 2**(n/2) * (n/2)!                           n even
    
    Parameters
    ----------
    n : int or array_like
        Calculate ``n!!``.  Arrays are only supported with `exact` set
        to False.  If ``n < 0``, the return value is 0.
    exact : bool, optional
        The result can be approximated rapidly using the gamma-formula
        above (default).  If `exact` is set to True, calculate the
        answer exactly using integer arithmetic.
    
    Returns
    -------
    nff : float or int
        Double factorial of `n`, as an int or a float depending on
        `exact`.
    
    Examples
    --------
    >>> from scipy.special import factorial2
    >>> factorial2(7, exact=False)
    array(105.00000000000001)
    >>> factorial2(7, exact=True)
    105L
",function,"('n', 'exact')","(nan, False)","(nan, 'bool')","('arg_info', 'arg_info')","('(n, exact=False)',)"
scipy,1.1.0,scipy.misc._factk,misc,factorialk,"Python Library Documentation: function factorialk in module scipy.special.basic

factorialk(n, k, exact=True)
    Multifactorial of n of order k, n(!!...!).
    
    This is the multifactorial of n skipping k values.  For example,
    
      factorialk(17, 4) = 17!!!! = 17 * 13 * 9 * 5 * 1
    
    In particular, for any integer ``n``, we have
    
      factorialk(n, 1) = factorial(n)
    
      factorialk(n, 2) = factorial2(n)
    
    Parameters
    ----------
    n : int
        Calculate multifactorial. If `n` < 0, the return value is 0.
    k : int
        Order of multifactorial.
    exact : bool, optional
        If exact is set to True, calculate the answer exactly using
        integer arithmetic.
    
    Returns
    -------
    val : int
        Multifactorial of `n`.
    
    Raises
    ------
    NotImplementedError
        Raises when exact is False
    
    Examples
    --------
    >>> from scipy.special import factorialk
    >>> factorialk(5, 1, exact=True)
    120L
    >>> factorialk(5, 3, exact=True)
    10L
",function,"('(n, k, exact=True)',)",scipy,1.1.0,scipy.misc._factk,misc,factorialk,"Python Library Documentation: function factorialk in module scipy.special.basic

factorialk(n, k, exact=True)
    Multifactorial of n of order k, n(!!...!).
    
    This is the multifactorial of n skipping k values.  For example,
    
      factorialk(17, 4) = 17!!!! = 17 * 13 * 9 * 5 * 1
    
    In particular, for any integer ``n``, we have
    
      factorialk(n, 1) = factorial(n)
    
      factorialk(n, 2) = factorial2(n)
    
    Parameters
    ----------
    n : int
        Calculate multifactorial. If `n` < 0, the return value is 0.
    k : int
        Order of multifactorial.
    exact : bool, optional
        If exact is set to True, calculate the answer exactly using
        integer arithmetic.
    
    Returns
    -------
    val : int
        Multifactorial of `n`.
    
    Raises
    ------
    NotImplementedError
        Raises when exact is False
    
    Examples
    --------
    >>> from scipy.special import factorialk
    >>> factorialk(5, 1, exact=True)
    120L
    >>> factorialk(5, 3, exact=True)
    10L
",function,"('n', 'k', 'exact')","(nan, nan, True)","(nan, nan, 'bool')","('arg_info', 'arg_info', 'arg_info')","('(n, k, exact=True)',)"
scipy,1.1.0,scipy.misc._info,misc,info,"Python Library Documentation: function info in module numpy.lib.utils

info(object=None, maxwidth=76, output=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>, toplevel='numpy')
    Get help information for a function, class, or module.
    
    Parameters
    ----------
    object : object or str, optional
        Input object or name to get information about. If `object` is a
        numpy object, its docstring is given. If it is a string, available
        modules are searched for matching objects.  If None, information
        about `info` itself is returned.
    maxwidth : int, optional
        Printing width.
    output : file like object, optional
        File like object that the output is written to, default is
        ``stdout``.  The object has to be opened in 'w' or 'a' mode.
    toplevel : str, optional
        Start search at this level.
    
    See Also
    --------
    source, lookfor
    
    Notes
    -----
    When used interactively with an object, ``np.info(obj)`` is equivalent
    to ``help(obj)`` on the Python prompt or ``obj?`` on the IPython
    prompt.
    
    Examples
    --------
    >>> np.info(np.polyval) # doctest: +SKIP
       polyval(p, x)
         Evaluate the polynomial p at x.
         ...
    
    When using a string for `object` it is possible to get multiple results.
    
    >>> np.info('fft') # doctest: +SKIP
         *** Found in numpy ***
    Core FFT routines
    ...
         *** Found in numpy.fft ***
     fft(a, n=None, axis=-1)
    ...
         *** Repeat reference found in numpy.fft.fftpack ***
         *** Total of 3 references found. ***
",function,"(""(object=None, maxwidth=76, output=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>, toplevel='numpy')"",)",scipy,1.1.0,scipy.misc._info,misc,info,"Python Library Documentation: function info in module numpy.lib.utils

info(object=None, maxwidth=76, output=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>, toplevel='numpy')
    Get help information for a function, class, or module.
    
    Parameters
    ----------
    object : object or str, optional
        Input object or name to get information about. If `object` is a
        numpy object, its docstring is given. If it is a string, available
        modules are searched for matching objects.  If None, information
        about `info` itself is returned.
    maxwidth : int, optional
        Printing width.
    output : file like object, optional
        File like object that the output is written to, default is
        ``stdout``.  The object has to be opened in 'w' or 'a' mode.
    toplevel : str, optional
        Start search at this level.
    
    See Also
    --------
    source, lookfor
    
    Notes
    -----
    When used interactively with an object, ``np.info(obj)`` is equivalent
    to ``help(obj)`` on the Python prompt or ``obj?`` on the IPython
    prompt.
    
    Examples
    --------
    >>> np.info(np.polyval) # doctest: +SKIP
       polyval(p, x)
         Evaluate the polynomial p at x.
         ...
    
    When using a string for `object` it is possible to get multiple results.
    
    >>> np.info('fft') # doctest: +SKIP
         *** Found in numpy ***
    Core FFT routines
    ...
         *** Found in numpy.fft ***
     fft(a, n=None, axis=-1)
    ...
         *** Repeat reference found in numpy.fft.fftpack ***
         *** Total of 3 references found. ***
",function,"('object', 'maxwidth', 'output', 'toplevel')","(None, 76, <_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>, 'numpy')","('NoneType', 'int', 'TextIOWrapper', 'str')","('arg_info', 'arg_info', 'arg_info', 'arg_info')","(""(object=None, maxwidth=76, output=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>, toplevel='numpy')"",)"
scipy,1.1.0,scipy.misc._lsm,misc,logsumexp,"Python Library Documentation: function logsumexp in module scipy.special._logsumexp

logsumexp(a, axis=None, b=None, keepdims=False, return_sign=False)
    Compute the log of the sum of exponentials of input elements.
    
    Parameters
    ----------
    a : array_like
        Input array.
    axis : None or int or tuple of ints, optional
        Axis or axes over which the sum is taken. By default `axis` is None,
        and all elements are summed.
    
        .. versionadded:: 0.11.0
    keepdims : bool, optional
        If this is set to True, the axes which are reduced are left in the
        result as dimensions with size one. With this option, the result
        will broadcast correctly against the original array.
    
        .. versionadded:: 0.15.0
    b : array-like, optional
        Scaling factor for exp(`a`) must be of the same shape as `a` or
        broadcastable to `a`. These values may be negative in order to
        implement subtraction.
    
        .. versionadded:: 0.12.0
    return_sign : bool, optional
        If this is set to True, the result will be a pair containing sign
        information; if False, results that are negative will be returned
        as NaN. Default is False (no sign information).
    
        .. versionadded:: 0.16.0
    
    Returns
    -------
    res : ndarray
        The result, ``np.log(np.sum(np.exp(a)))`` calculated in a numerically
        more stable way. If `b` is given then ``np.log(np.sum(b*np.exp(a)))``
        is returned.
    sgn : ndarray
        If return_sign is True, this will be an array of floating-point
        numbers matching res and +1, 0, or -1 depending on the sign
        of the result. If False, only one result is returned.
    
    See Also
    --------
    numpy.logaddexp, numpy.logaddexp2
    
    Notes
    -----
    Numpy has a logaddexp function which is very similar to `logsumexp`, but
    only handles two arguments. `logaddexp.reduce` is similar to this
    function, but may be less stable.
    
    Examples
    --------
    >>> from scipy.special import logsumexp
    >>> a = np.arange(10)
    >>> np.log(np.sum(np.exp(a)))
    9.4586297444267107
    >>> logsumexp(a)
    9.4586297444267107
    
    With weights
    
    >>> a = np.arange(10)
    >>> b = np.arange(10, 0, -1)
    >>> logsumexp(a, b=b)
    9.9170178533034665
    >>> np.log(np.sum(b*np.exp(a)))
    9.9170178533034647
    
    Returning a sign flag
    
    >>> logsumexp([1,2],b=[1,-1],return_sign=True)
    (1.5413248546129181, -1.0)
    
    Notice that `logsumexp` does not directly support masked arrays. To use it
    on a masked array, convert the mask into zero weights:
    
    >>> a = np.ma.array([np.log(2), 2, np.log(3)],
    ...                  mask=[False, True, False])
    >>> b = (~a.mask).astype(int)
    >>> logsumexp(a.data, b=b), np.log(5)
    1.6094379124341005, 1.6094379124341005
",function,"('(a, axis=None, b=None, keepdims=False, return_sign=False)',)",scipy,1.1.0,scipy.misc._lsm,misc,logsumexp,"Python Library Documentation: function logsumexp in module scipy.special._logsumexp

logsumexp(a, axis=None, b=None, keepdims=False, return_sign=False)
    Compute the log of the sum of exponentials of input elements.
    
    Parameters
    ----------
    a : array_like
        Input array.
    axis : None or int or tuple of ints, optional
        Axis or axes over which the sum is taken. By default `axis` is None,
        and all elements are summed.
    
        .. versionadded:: 0.11.0
    keepdims : bool, optional
        If this is set to True, the axes which are reduced are left in the
        result as dimensions with size one. With this option, the result
        will broadcast correctly against the original array.
    
        .. versionadded:: 0.15.0
    b : array-like, optional
        Scaling factor for exp(`a`) must be of the same shape as `a` or
        broadcastable to `a`. These values may be negative in order to
        implement subtraction.
    
        .. versionadded:: 0.12.0
    return_sign : bool, optional
        If this is set to True, the result will be a pair containing sign
        information; if False, results that are negative will be returned
        as NaN. Default is False (no sign information).
    
        .. versionadded:: 0.16.0
    
    Returns
    -------
    res : ndarray
        The result, ``np.log(np.sum(np.exp(a)))`` calculated in a numerically
        more stable way. If `b` is given then ``np.log(np.sum(b*np.exp(a)))``
        is returned.
    sgn : ndarray
        If return_sign is True, this will be an array of floating-point
        numbers matching res and +1, 0, or -1 depending on the sign
        of the result. If False, only one result is returned.
    
    See Also
    --------
    numpy.logaddexp, numpy.logaddexp2
    
    Notes
    -----
    Numpy has a logaddexp function which is very similar to `logsumexp`, but
    only handles two arguments. `logaddexp.reduce` is similar to this
    function, but may be less stable.
    
    Examples
    --------
    >>> from scipy.special import logsumexp
    >>> a = np.arange(10)
    >>> np.log(np.sum(np.exp(a)))
    9.4586297444267107
    >>> logsumexp(a)
    9.4586297444267107
    
    With weights
    
    >>> a = np.arange(10)
    >>> b = np.arange(10, 0, -1)
    >>> logsumexp(a, b=b)
    9.9170178533034665
    >>> np.log(np.sum(b*np.exp(a)))
    9.9170178533034647
    
    Returning a sign flag
    
    >>> logsumexp([1,2],b=[1,-1],return_sign=True)
    (1.5413248546129181, -1.0)
    
    Notice that `logsumexp` does not directly support masked arrays. To use it
    on a masked array, convert the mask into zero weights:
    
    >>> a = np.ma.array([np.log(2), 2, np.log(3)],
    ...                  mask=[False, True, False])
    >>> b = (~a.mask).astype(int)
    >>> logsumexp(a.data, b=b), np.log(5)
    1.6094379124341005, 1.6094379124341005
",function,"('a', 'axis', 'b', 'keepdims', 'return_sign')","(nan, None, None, False, False)","(nan, 'NoneType', 'NoneType', 'bool', 'bool')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(a, axis=None, b=None, keepdims=False, return_sign=False)',)"
scipy,1.1.0,scipy.misc._pade,misc,pade,"Python Library Documentation: function pade in module scipy.interpolate._pade

pade(an, m)
    Return Pade approximation to a polynomial as the ratio of two polynomials.
    
    Parameters
    ----------
    an : (N,) array_like
        Taylor series coefficients.
    m : int
        The order of the returned approximating polynomials.
    
    Returns
    -------
    p, q : Polynomial class
        The Pade approximation of the polynomial defined by `an` is
        ``p(x)/q(x)``.
    
    Examples
    --------
    >>> from scipy.interpolate import pade
    >>> e_exp = [1.0, 1.0, 1.0/2.0, 1.0/6.0, 1.0/24.0, 1.0/120.0]
    >>> p, q = pade(e_exp, 2)
    
    >>> e_exp.reverse()
    >>> e_poly = np.poly1d(e_exp)
    
    Compare ``e_poly(x)`` and the Pade approximation ``p(x)/q(x)``
    
    >>> e_poly(1)
    2.7166666666666668
    
    >>> p(1)/q(1)
    2.7179487179487181
",function,"('(an, m)',)",scipy,1.1.0,scipy.misc._pade,misc,pade,"Python Library Documentation: function pade in module scipy.interpolate._pade

pade(an, m)
    Return Pade approximation to a polynomial as the ratio of two polynomials.
    
    Parameters
    ----------
    an : (N,) array_like
        Taylor series coefficients.
    m : int
        The order of the returned approximating polynomials.
    
    Returns
    -------
    p, q : Polynomial class
        The Pade approximation of the polynomial defined by `an` is
        ``p(x)/q(x)``.
    
    Examples
    --------
    >>> from scipy.interpolate import pade
    >>> e_exp = [1.0, 1.0, 1.0/2.0, 1.0/6.0, 1.0/24.0, 1.0/120.0]
    >>> p, q = pade(e_exp, 2)
    
    >>> e_exp.reverse()
    >>> e_poly = np.poly1d(e_exp)
    
    Compare ``e_poly(x)`` and the Pade approximation ``p(x)/q(x)``
    
    >>> e_poly(1)
    2.7166666666666668
    
    >>> p(1)/q(1)
    2.7179487179487181
",function,"('an', 'm')","(nan, nan)","(nan, nan)","('arg_info', 'arg_info')","('(an, m)',)"
scipy,1.1.0,scipy.misc._source,misc,source,"Python Library Documentation: function source in module numpy.lib.utils

source(object, output=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>)
    Print or write to a file the source code for a NumPy object.
    
    The source code is only returned for objects written in Python. Many
    functions and classes are defined in C and will therefore not return
    useful information.
    
    Parameters
    ----------
    object : numpy object
        Input object. This can be any object (function, class, module,
        ...).
    output : file object, optional
        If `output` not supplied then source code is printed to screen
        (sys.stdout).  File object must be created with either write 'w' or
        append 'a' modes.
    
    See Also
    --------
    lookfor, info
    
    Examples
    --------
    >>> np.source(np.interp)                        #doctest: +SKIP
    In file: /usr/lib/python2.6/dist-packages/numpy/lib/function_base.py
    def interp(x, xp, fp, left=None, right=None):
        """""".... (full docstring printed)""""""
        if isinstance(x, (float, int, number)):
            return compiled_interp([x], xp, fp, left, right).item()
        else:
            return compiled_interp(x, xp, fp, left, right)
    
    The source code is only returned for objects written in Python.
    
    >>> np.source(np.array)                         #doctest: +SKIP
    Not available for this object.
",function,"(""(object, output=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>)"",)",scipy,1.1.0,scipy.misc._source,misc,source,"Python Library Documentation: function source in module numpy.lib.utils

source(object, output=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>)
    Print or write to a file the source code for a NumPy object.
    
    The source code is only returned for objects written in Python. Many
    functions and classes are defined in C and will therefore not return
    useful information.
    
    Parameters
    ----------
    object : numpy object
        Input object. This can be any object (function, class, module,
        ...).
    output : file object, optional
        If `output` not supplied then source code is printed to screen
        (sys.stdout).  File object must be created with either write 'w' or
        append 'a' modes.
    
    See Also
    --------
    lookfor, info
    
    Examples
    --------
    >>> np.source(np.interp)                        #doctest: +SKIP
    In file: /usr/lib/python2.6/dist-packages/numpy/lib/function_base.py
    def interp(x, xp, fp, left=None, right=None):
        """""".... (full docstring printed)""""""
        if isinstance(x, (float, int, number)):
            return compiled_interp([x], xp, fp, left, right).item()
        else:
            return compiled_interp(x, xp, fp, left, right)
    
    The source code is only returned for objects written in Python.
    
    >>> np.source(np.array)                         #doctest: +SKIP
    Not available for this object.
",function,"('object', 'output')","(nan, <_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>)","(nan, 'TextIOWrapper')","('arg_info', 'arg_info')","(""(object, output=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>)"",)"
scipy,1.1.0,scipy.misc._who,misc,who,"Python Library Documentation: function who in module numpy.lib.utils

who(vardict=None)
    Print the NumPy arrays in the given dictionary.
    
    If there is no dictionary passed in or `vardict` is None then returns
    NumPy arrays in the globals() dictionary (all NumPy arrays in the
    namespace).
    
    Parameters
    ----------
    vardict : dict, optional
        A dictionary possibly containing ndarrays.  Default is globals().
    
    Returns
    -------
    out : None
        Returns 'None'.
    
    Notes
    -----
    Prints out the name, shape, bytes and type of all of the ndarrays
    present in `vardict`.
    
    Examples
    --------
    >>> a = np.arange(10)
    >>> b = np.ones(20)
    >>> np.who()
    Name            Shape            Bytes            Type
    ===========================================================
    a               10               40               int32
    b               20               160              float64
    Upper bound on total bytes  =       200
    
    >>> d = {'x': np.arange(2.0), 'y': np.arange(3.0), 'txt': 'Some str',
    ... 'idx':5}
    >>> np.who(d)
    Name            Shape            Bytes            Type
    ===========================================================
    y               3                24               float64
    x               2                16               float64
    Upper bound on total bytes  =       40
",function,"('(vardict=None)',)",scipy,1.1.0,scipy.misc._who,misc,who,"Python Library Documentation: function who in module numpy.lib.utils

who(vardict=None)
    Print the NumPy arrays in the given dictionary.
    
    If there is no dictionary passed in or `vardict` is None then returns
    NumPy arrays in the globals() dictionary (all NumPy arrays in the
    namespace).
    
    Parameters
    ----------
    vardict : dict, optional
        A dictionary possibly containing ndarrays.  Default is globals().
    
    Returns
    -------
    out : None
        Returns 'None'.
    
    Notes
    -----
    Prints out the name, shape, bytes and type of all of the ndarrays
    present in `vardict`.
    
    Examples
    --------
    >>> a = np.arange(10)
    >>> b = np.ones(20)
    >>> np.who()
    Name            Shape            Bytes            Type
    ===========================================================
    a               10               40               int32
    b               20               160              float64
    Upper bound on total bytes  =       200
    
    >>> d = {'x': np.arange(2.0), 'y': np.arange(3.0), 'txt': 'Some str',
    ... 'idx':5}
    >>> np.who(d)
    Name            Shape            Bytes            Type
    ===========================================================
    y               3                24               float64
    x               2                16               float64
    Upper bound on total bytes  =       40
",function,"('vardict',)","(None,)","('NoneType',)","('arg_info',)","('(vardict=None)',)"
scipy,1.1.0,scipy.misc.ascent,misc,ascent,"Python Library Documentation: function ascent in module scipy.misc.common

ascent()
    Get an 8-bit grayscale bit-depth, 512 x 512 derived image for easy use in demos
    
    The image is derived from accent-to-the-top.jpg at
    http://www.public-domain-image.com/people-public-domain-images-pictures/
    
    Parameters
    ----------
    None
    
    Returns
    -------
    ascent : ndarray
       convenient image to use for testing and demonstration
    
    Examples
    --------
    >>> import scipy.misc
    >>> ascent = scipy.misc.ascent()
    >>> ascent.shape
    (512, 512)
    >>> ascent.max()
    255
    
    >>> import matplotlib.pyplot as plt
    >>> plt.gray()
    >>> plt.imshow(ascent)
    >>> plt.show()
",function,"('()',)",scipy,1.1.0,scipy.misc.ascent,misc,ascent,"Python Library Documentation: function ascent in module scipy.misc.common

ascent()
    Get an 8-bit grayscale bit-depth, 512 x 512 derived image for easy use in demos
    
    The image is derived from accent-to-the-top.jpg at
    http://www.public-domain-image.com/people-public-domain-images-pictures/
    
    Parameters
    ----------
    None
    
    Returns
    -------
    ascent : ndarray
       convenient image to use for testing and demonstration
    
    Examples
    --------
    >>> import scipy.misc
    >>> ascent = scipy.misc.ascent()
    >>> ascent.shape
    (512, 512)
    >>> ascent.max()
    255
    
    >>> import matplotlib.pyplot as plt
    >>> plt.gray()
    >>> plt.imshow(ascent)
    >>> plt.show()
",function,(),(),(),(),"('()',)"
scipy,1.1.0,scipy.misc.bytescale,misc,bytescale,"Python Library Documentation: function bytescale in module numpy.lib.utils

bytescale(*args, **kwds)
    `bytescale` is deprecated!
    `bytescale` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.
    
    
        Byte scales an array (image).
    
        Byte scaling means converting the input image to uint8 dtype and scaling
        the range to ``(low, high)`` (default 0-255).
        If the input image already has dtype uint8, no scaling is done.
    
        This function is only available if Python Imaging Library (PIL) is installed.
    
        Parameters
        ----------
        data : ndarray
            PIL image data array.
        cmin : scalar, optional
            Bias scaling of small values. Default is ``data.min()``.
        cmax : scalar, optional
            Bias scaling of large values. Default is ``data.max()``.
        high : scalar, optional
            Scale max value to `high`.  Default is 255.
        low : scalar, optional
            Scale min value to `low`.  Default is 0.
    
        Returns
        -------
        img_array : uint8 ndarray
            The byte-scaled array.
    
        Examples
        --------
        >>> from scipy.misc import bytescale
        >>> img = np.array([[ 91.06794177,   3.39058326,  84.4221549 ],
        ...                 [ 73.88003259,  80.91433048,   4.88878881],
        ...                 [ 51.53875334,  34.45808177,  27.5873488 ]])
        >>> bytescale(img)
        array([[255,   0, 236],
               [205, 225,   4],
               [140,  90,  70]], dtype=uint8)
        >>> bytescale(img, high=200, low=100)
        array([[200, 100, 192],
               [180, 188, 102],
               [155, 135, 128]], dtype=uint8)
        >>> bytescale(img, cmin=0, cmax=255)
        array([[91,  3, 84],
               [74, 81,  5],
               [52, 34, 28]], dtype=uint8)
",function,"('(*args, **kwds)',)",scipy,1.1.0,scipy.misc.bytescale,misc,bytescale,"Python Library Documentation: function bytescale in module numpy.lib.utils

bytescale(*args, **kwds)
    `bytescale` is deprecated!
    `bytescale` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.
    
    
        Byte scales an array (image).
    
        Byte scaling means converting the input image to uint8 dtype and scaling
        the range to ``(low, high)`` (default 0-255).
        If the input image already has dtype uint8, no scaling is done.
    
        This function is only available if Python Imaging Library (PIL) is installed.
    
        Parameters
        ----------
        data : ndarray
            PIL image data array.
        cmin : scalar, optional
            Bias scaling of small values. Default is ``data.min()``.
        cmax : scalar, optional
            Bias scaling of large values. Default is ``data.max()``.
        high : scalar, optional
            Scale max value to `high`.  Default is 255.
        low : scalar, optional
            Scale min value to `low`.  Default is 0.
    
        Returns
        -------
        img_array : uint8 ndarray
            The byte-scaled array.
    
        Examples
        --------
        >>> from scipy.misc import bytescale
        >>> img = np.array([[ 91.06794177,   3.39058326,  84.4221549 ],
        ...                 [ 73.88003259,  80.91433048,   4.88878881],
        ...                 [ 51.53875334,  34.45808177,  27.5873488 ]])
        >>> bytescale(img)
        array([[255,   0, 236],
               [205, 225,   4],
               [140,  90,  70]], dtype=uint8)
        >>> bytescale(img, high=200, low=100)
        array([[200, 100, 192],
               [180, 188, 102],
               [155, 135, 128]], dtype=uint8)
        >>> bytescale(img, cmin=0, cmax=255)
        array([[91,  3, 84],
               [74, 81,  5],
               [52, 34, 28]], dtype=uint8)
",function,(),(),(),(),"('(*args, **kwds)',)"
scipy,1.1.0,scipy.misc.central_diff_weights,misc,central_diff_weights,"Python Library Documentation: function central_diff_weights in module scipy.misc.common

central_diff_weights(Np, ndiv=1)
    Return weights for an Np-point central derivative.
    
    Assumes equally-spaced function points.
    
    If weights are in the vector w, then
    derivative is w[0] * f(x-ho*dx) + ... + w[-1] * f(x+h0*dx)
    
    Parameters
    ----------
    Np : int
        Number of points for the central derivative.
    ndiv : int, optional
        Number of divisions.  Default is 1.
    
    Notes
    -----
    Can be inaccurate for large number of points.
",function,"('(Np, ndiv=1)',)",scipy,1.1.0,scipy.misc.central_diff_weights,misc,central_diff_weights,"Python Library Documentation: function central_diff_weights in module scipy.misc.common

central_diff_weights(Np, ndiv=1)
    Return weights for an Np-point central derivative.
    
    Assumes equally-spaced function points.
    
    If weights are in the vector w, then
    derivative is w[0] * f(x-ho*dx) + ... + w[-1] * f(x+h0*dx)
    
    Parameters
    ----------
    Np : int
        Number of points for the central derivative.
    ndiv : int, optional
        Number of divisions.  Default is 1.
    
    Notes
    -----
    Can be inaccurate for large number of points.
",function,"('Np', 'ndiv')","(nan, 1)","(nan, 'int')","('arg_info', 'arg_info')","('(Np, ndiv=1)',)"
scipy,1.1.0,scipy.misc.comb,misc,comb,"Python Library Documentation: function comb in module numpy.lib.utils

comb(*args, **kwds)
    `comb` is deprecated!
    Importing `comb` from scipy.misc is deprecated in scipy 1.0.0. Use `scipy.special.comb` instead.
    
    The number of combinations of N things taken k at a time.
    
        This is often expressed as ""N choose k"".
    
        Parameters
        ----------
        N : int, ndarray
            Number of things.
        k : int, ndarray
            Number of elements taken.
        exact : bool, optional
            If `exact` is False, then floating point precision is used, otherwise
            exact long integer is computed.
        repetition : bool, optional
            If `repetition` is True, then the number of combinations with
            repetition is computed.
    
        Returns
        -------
        val : int, float, ndarray
            The total number of combinations.
    
        See Also
        --------
        binom : Binomial coefficient ufunc
    
        Notes
        -----
        - Array arguments accepted only for exact=False case.
        - If k > N, N < 0, or k < 0, then a 0 is returned.
    
        Examples
        --------
        >>> from scipy.special import comb
        >>> k = np.array([3, 4])
        >>> n = np.array([10, 10])
        >>> comb(n, k, exact=False)
        array([ 120.,  210.])
        >>> comb(10, 3, exact=True)
        120L
        >>> comb(10, 3, exact=True, repetition=True)
        220L
",function,"('(*args, **kwds)',)",scipy,1.1.0,scipy.misc.comb,misc,comb,"Python Library Documentation: function comb in module numpy.lib.utils

comb(*args, **kwds)
    `comb` is deprecated!
    Importing `comb` from scipy.misc is deprecated in scipy 1.0.0. Use `scipy.special.comb` instead.
    
    The number of combinations of N things taken k at a time.
    
        This is often expressed as ""N choose k"".
    
        Parameters
        ----------
        N : int, ndarray
            Number of things.
        k : int, ndarray
            Number of elements taken.
        exact : bool, optional
            If `exact` is False, then floating point precision is used, otherwise
            exact long integer is computed.
        repetition : bool, optional
            If `repetition` is True, then the number of combinations with
            repetition is computed.
    
        Returns
        -------
        val : int, float, ndarray
            The total number of combinations.
    
        See Also
        --------
        binom : Binomial coefficient ufunc
    
        Notes
        -----
        - Array arguments accepted only for exact=False case.
        - If k > N, N < 0, or k < 0, then a 0 is returned.
    
        Examples
        --------
        >>> from scipy.special import comb
        >>> k = np.array([3, 4])
        >>> n = np.array([10, 10])
        >>> comb(n, k, exact=False)
        array([ 120.,  210.])
        >>> comb(10, 3, exact=True)
        120L
        >>> comb(10, 3, exact=True, repetition=True)
        220L
",function,(),(),(),(),"('(*args, **kwds)',)"
scipy,1.1.0,scipy.misc.derivative,misc,derivative,"Python Library Documentation: function derivative in module scipy.misc.common

derivative(func, x0, dx=1.0, n=1, args=(), order=3)
    Find the n-th derivative of a function at a point.
    
    Given a function, use a central difference formula with spacing `dx` to
    compute the `n`-th derivative at `x0`.
    
    Parameters
    ----------
    func : function
        Input function.
    x0 : float
        The point at which `n`-th derivative is found.
    dx : float, optional
        Spacing.
    n : int, optional
        Order of the derivative. Default is 1.
    args : tuple, optional
        Arguments
    order : int, optional
        Number of points to use, must be odd.
    
    Notes
    -----
    Decreasing the step size too small can result in round-off error.
    
    Examples
    --------
    >>> from scipy.misc import derivative
    >>> def f(x):
    ...     return x**3 + x**2
    >>> derivative(f, 1.0, dx=1e-6)
    4.9999999999217337
",function,"('(func, x0, dx=1.0, n=1, args=(), order=3)',)",scipy,1.1.0,scipy.misc.derivative,misc,derivative,"Python Library Documentation: function derivative in module scipy.misc.common

derivative(func, x0, dx=1.0, n=1, args=(), order=3)
    Find the n-th derivative of a function at a point.
    
    Given a function, use a central difference formula with spacing `dx` to
    compute the `n`-th derivative at `x0`.
    
    Parameters
    ----------
    func : function
        Input function.
    x0 : float
        The point at which `n`-th derivative is found.
    dx : float, optional
        Spacing.
    n : int, optional
        Order of the derivative. Default is 1.
    args : tuple, optional
        Arguments
    order : int, optional
        Number of points to use, must be odd.
    
    Notes
    -----
    Decreasing the step size too small can result in round-off error.
    
    Examples
    --------
    >>> from scipy.misc import derivative
    >>> def f(x):
    ...     return x**3 + x**2
    >>> derivative(f, 1.0, dx=1e-6)
    4.9999999999217337
",function,"('func', 'x0', 'dx', 'n', 'args', 'order')","(nan, nan, 1.0, 1, (), 3)","(nan, nan, 'float', 'int', 'tuple', 'int')","('arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info', 'arg_info')","('(func, x0, dx=1.0, n=1, args=(), order=3)',)"
scipy,1.1.0,scipy.misc.electrocardiogram,misc,electrocardiogram,"Python Library Documentation: function electrocardiogram in module scipy.misc.common

electrocardiogram()
    Load an electrocardiogram as an example for a one-dimensional signal.
    
    The returned signal is a 5 minute long electrocardiogram (ECG), a medical
    recording of the heart's electrical activity, sampled at 360 Hz.
    
    Returns
    -------
    ecg : ndarray
        The electrocardiogram in millivolt (mV) sampled at 360 Hz.
    
    Notes
    -----
    The provided signal is an excerpt (19:35 to 24:35) from the `record 208`_
    (lead MLII) provided by the MIT-BIH Arrhythmia Database [1]_ on
    PhysioNet [2]_. The excerpt includes noise induced artifacts, typical
    heartbeats as well as pathological changes.
    
    .. _record 208: https://physionet.org/physiobank/database/html/mitdbdir/records.htm#208
    
    .. versionadded:: 1.1.0
    
    References
    ----------
    .. [1] Moody GB, Mark RG. The impact of the MIT-BIH Arrhythmia Database.
           IEEE Eng in Med and Biol 20(3):45-50 (May-June 2001).
           (PMID: 11446209); https://doi.org/10.13026/C2F305
    .. [2] Goldberger AL, Amaral LAN, Glass L, Hausdorff JM, Ivanov PCh,
           Mark RG, Mietus JE, Moody GB, Peng C-K, Stanley HE. PhysioBank,
           PhysioToolkit, and PhysioNet: Components of a New Research Resource
           for Complex Physiologic Signals. Circulation 101(23):e215-e220;
           https://doi.org/10.1161/01.CIR.101.23.e215
    
    Examples
    --------
    >>> from scipy.misc import electrocardiogram
    >>> ecg = electrocardiogram()
    >>> ecg
    array([-0.245, -0.215, -0.185, ..., -0.405, -0.395, -0.385])
    >>> ecg.shape, ecg.mean(), ecg.std()
    ((108000,), -0.16510875, 0.5992473991177294)
    
    As stated the signal features several areas with a different morphology.
    E.g. the first few seconds show the electrical activity of a heart in
    normal sinus rhythm as seen below.
    
    >>> import matplotlib.pyplot as plt
    >>> fs = 360
    >>> time = np.arange(ecg.size) / fs
    >>> plt.plot(time, ecg)
    >>> plt.xlabel(""time in s"")
    >>> plt.ylabel(""ECG in mV"")
    >>> plt.xlim(9, 10.2)
    >>> plt.ylim(-1, 1.5)
    >>> plt.show()
    
    After second 16 however, the first premature ventricular contractions, also
    called extrasystoles, appear. These have a different morphology compared to
    typical heartbeats. The difference can easily be observed in the following
    plot.
    
    >>> plt.plot(time, ecg)
    >>> plt.xlabel(""time in s"")
    >>> plt.ylabel(""ECG in mV"")
    >>> plt.xlim(46.5, 50)
    >>> plt.ylim(-2, 1.5)
    >>> plt.show()
    
    At several points large artifacts disturb the recording, e.g.:
    
    >>> plt.plot(time, ecg)
    >>> plt.xlabel(""time in s"")
    >>> plt.ylabel(""ECG in mV"")
    >>> plt.xlim(207, 215)
    >>> plt.ylim(-2, 3.5)
    >>> plt.show()
    
    Finally, examining the power spectrum reveals that most of the biosignal is
    made up of lower frequencies. At 60 Hz the noise induced by the mains
    electricity can be clearly observed.
    
    >>> from scipy.signal import welch
    >>> f, Pxx = welch(ecg, fs=fs, nperseg=2048, scaling=""spectrum"")
    >>> plt.semilogy(f, Pxx)
    >>> plt.xlabel(""Frequency in Hz"")
    >>> plt.ylabel(""Power spectrum of the ECG in mV**2"")
    >>> plt.xlim(f[[0, -1]])
    >>> plt.show()
",function,"('()',)",scipy,1.1.0,scipy.misc.electrocardiogram,misc,electrocardiogram,"Python Library Documentation: function electrocardiogram in module scipy.misc.common

electrocardiogram()
    Load an electrocardiogram as an example for a one-dimensional signal.
    
    The returned signal is a 5 minute long electrocardiogram (ECG), a medical
    recording of the heart's electrical activity, sampled at 360 Hz.
    
    Returns
    -------
    ecg : ndarray
        The electrocardiogram in millivolt (mV) sampled at 360 Hz.
    
    Notes
    -----
    The provided signal is an excerpt (19:35 to 24:35) from the `record 208`_
    (lead MLII) provided by the MIT-BIH Arrhythmia Database [1]_ on
    PhysioNet [2]_. The excerpt includes noise induced artifacts, typical
    heartbeats as well as pathological changes.
    
    .. _record 208: https://physionet.org/physiobank/database/html/mitdbdir/records.htm#208
    
    .. versionadded:: 1.1.0
    
    References
    ----------
    .. [1] Moody GB, Mark RG. The impact of the MIT-BIH Arrhythmia Database.
           IEEE Eng in Med and Biol 20(3):45-50 (May-June 2001).
           (PMID: 11446209); https://doi.org/10.13026/C2F305
    .. [2] Goldberger AL, Amaral LAN, Glass L, Hausdorff JM, Ivanov PCh,
           Mark RG, Mietus JE, Moody GB, Peng C-K, Stanley HE. PhysioBank,
           PhysioToolkit, and PhysioNet: Components of a New Research Resource
           for Complex Physiologic Signals. Circulation 101(23):e215-e220;
           https://doi.org/10.1161/01.CIR.101.23.e215
    
    Examples
    --------
    >>> from scipy.misc import electrocardiogram
    >>> ecg = electrocardiogram()
    >>> ecg
    array([-0.245, -0.215, -0.185, ..., -0.405, -0.395, -0.385])
    >>> ecg.shape, ecg.mean(), ecg.std()
    ((108000,), -0.16510875, 0.5992473991177294)
    
    As stated the signal features several areas with a different morphology.
    E.g. the first few seconds show the electrical activity of a heart in
    normal sinus rhythm as seen below.
    
    >>> import matplotlib.pyplot as plt
    >>> fs = 360
    >>> time = np.arange(ecg.size) / fs
    >>> plt.plot(time, ecg)
    >>> plt.xlabel(""time in s"")
    >>> plt.ylabel(""ECG in mV"")
    >>> plt.xlim(9, 10.2)
    >>> plt.ylim(-1, 1.5)
    >>> plt.show()
    
    After second 16 however, the first premature ventricular contractions, also
    called extrasystoles, appear. These have a different morphology compared to
    typical heartbeats. The difference can easily be observed in the following
    plot.
    
    >>> plt.plot(time, ecg)
    >>> plt.xlabel(""time in s"")
    >>> plt.ylabel(""ECG in mV"")
    >>> plt.xlim(46.5, 50)
    >>> plt.ylim(-2, 1.5)
    >>> plt.show()
    
    At several points large artifacts disturb the recording, e.g.:
    
    >>> plt.plot(time, ecg)
    >>> plt.xlabel(""time in s"")
    >>> plt.ylabel(""ECG in mV"")
    >>> plt.xlim(207, 215)
    >>> plt.ylim(-2, 3.5)
    >>> plt.show()
    
    Finally, examining the power spectrum reveals that most of the biosignal is
    made up of lower frequencies. At 60 Hz the noise induced by the mains
    electricity can be clearly observed.
    
    >>> from scipy.signal import welch
    >>> f, Pxx = welch(ecg, fs=fs, nperseg=2048, scaling=""spectrum"")
    >>> plt.semilogy(f, Pxx)
    >>> plt.xlabel(""Frequency in Hz"")
    >>> plt.ylabel(""Power spectrum of the ECG in mV**2"")
    >>> plt.xlim(f[[0, -1]])
    >>> plt.show()
",function,(),(),(),(),"('()',)"
scipy,1.1.0,scipy.misc.face,misc,face,"Python Library Documentation: function face in module scipy.misc.common

face(gray=False)
    Get a 1024 x 768, color image of a raccoon face.
    
    raccoon-procyon-lotor.jpg at http://www.public-domain-image.com
    
    Parameters
    ----------
    gray : bool, optional
        If True return 8-bit grey-scale image, otherwise return a color image
    
    Returns
    -------
    face : ndarray
        image of a racoon face
    
    Examples
    --------
    >>> import scipy.misc
    >>> face = scipy.misc.face()
    >>> face.shape
    (768, 1024, 3)
    >>> face.max()
    255
    >>> face.dtype
    dtype('uint8')
    
    >>> import matplotlib.pyplot as plt
    >>> plt.gray()
    >>> plt.imshow(face)
    >>> plt.show()
",function,"('(gray=False)',)",scipy,1.1.0,scipy.misc.face,misc,face,"Python Library Documentation: function face in module scipy.misc.common

face(gray=False)
    Get a 1024 x 768, color image of a raccoon face.
    
    raccoon-procyon-lotor.jpg at http://www.public-domain-image.com
    
    Parameters
    ----------
    gray : bool, optional
        If True return 8-bit grey-scale image, otherwise return a color image
    
    Returns
    -------
    face : ndarray
        image of a racoon face
    
    Examples
    --------
    >>> import scipy.misc
    >>> face = scipy.misc.face()
    >>> face.shape
    (768, 1024, 3)
    >>> face.max()
    255
    >>> face.dtype
    dtype('uint8')
    
    >>> import matplotlib.pyplot as plt
    >>> plt.gray()
    >>> plt.imshow(face)
    >>> plt.show()
",function,"('gray',)","(False,)","('bool',)","('arg_info',)","('(gray=False)',)"
scipy,1.1.0,scipy.misc.factorial,misc,factorial,"Python Library Documentation: function factorial in module numpy.lib.utils

factorial(*args, **kwds)
    `factorial` is deprecated!
    Importing `factorial` from scipy.misc is deprecated in scipy 1.0.0. Use `scipy.special.factorial` instead.
    
    
        The factorial of a number or array of numbers.
    
        The factorial of non-negative integer `n` is the product of all
        positive integers less than or equal to `n`::
    
            n! = n * (n - 1) * (n - 2) * ... * 1
    
        Parameters
        ----------
        n : int or array_like of ints
            Input values.  If ``n < 0``, the return value is 0.
        exact : bool, optional
            If True, calculate the answer exactly using long integer arithmetic.
            If False, result is approximated in floating point rapidly using the
            `gamma` function.
            Default is False.
    
        Returns
        -------
        nf : float or int or ndarray
            Factorial of `n`, as integer or float depending on `exact`.
    
        Notes
        -----
        For arrays with ``exact=True``, the factorial is computed only once, for
        the largest input, with each other result computed in the process.
        The output dtype is increased to ``int64`` or ``object`` if necessary.
    
        With ``exact=False`` the factorial is approximated using the gamma
        function:
    
        .. math:: n! = \Gamma(n+1)
    
        Examples
        --------
        >>> from scipy.special import factorial
        >>> arr = np.array([3, 4, 5])
        >>> factorial(arr, exact=False)
        array([   6.,   24.,  120.])
        >>> factorial(arr, exact=True)
        array([  6,  24, 120])
        >>> factorial(5, exact=True)
        120L
",function,"('(*args, **kwds)',)",scipy,1.1.0,scipy.misc.factorial,misc,factorial,"Python Library Documentation: function factorial in module numpy.lib.utils

factorial(*args, **kwds)
    `factorial` is deprecated!
    Importing `factorial` from scipy.misc is deprecated in scipy 1.0.0. Use `scipy.special.factorial` instead.
    
    
        The factorial of a number or array of numbers.
    
        The factorial of non-negative integer `n` is the product of all
        positive integers less than or equal to `n`::
    
            n! = n * (n - 1) * (n - 2) * ... * 1
    
        Parameters
        ----------
        n : int or array_like of ints
            Input values.  If ``n < 0``, the return value is 0.
        exact : bool, optional
            If True, calculate the answer exactly using long integer arithmetic.
            If False, result is approximated in floating point rapidly using the
            `gamma` function.
            Default is False.
    
        Returns
        -------
        nf : float or int or ndarray
            Factorial of `n`, as integer or float depending on `exact`.
    
        Notes
        -----
        For arrays with ``exact=True``, the factorial is computed only once, for
        the largest input, with each other result computed in the process.
        The output dtype is increased to ``int64`` or ``object`` if necessary.
    
        With ``exact=False`` the factorial is approximated using the gamma
        function:
    
        .. math:: n! = \Gamma(n+1)
    
        Examples
        --------
        >>> from scipy.special import factorial
        >>> arr = np.array([3, 4, 5])
        >>> factorial(arr, exact=False)
        array([   6.,   24.,  120.])
        >>> factorial(arr, exact=True)
        array([  6,  24, 120])
        >>> factorial(5, exact=True)
        120L
",function,(),(),(),(),"('(*args, **kwds)',)"
scipy,1.1.0,scipy.misc.factorial2,misc,factorial2,"Python Library Documentation: function factorial2 in module numpy.lib.utils

factorial2(*args, **kwds)
    `factorial2` is deprecated!
    Importing `factorial2` from scipy.misc is deprecated in scipy 1.0.0. Use `scipy.special.factorial2` instead.
    
    Double factorial.
    
        This is the factorial with every second value skipped.  E.g., ``7!! = 7 * 5
        * 3 * 1``.  It can be approximated numerically as::
    
          n!! = special.gamma(n/2+1)*2**((m+1)/2)/sqrt(pi)  n odd
              = 2**(n/2) * (n/2)!                           n even
    
        Parameters
        ----------
        n : int or array_like
            Calculate ``n!!``.  Arrays are only supported with `exact` set
            to False.  If ``n < 0``, the return value is 0.
        exact : bool, optional
            The result can be approximated rapidly using the gamma-formula
            above (default).  If `exact` is set to True, calculate the
            answer exactly using integer arithmetic.
    
        Returns
        -------
        nff : float or int
            Double factorial of `n`, as an int or a float depending on
            `exact`.
    
        Examples
        --------
        >>> from scipy.special import factorial2
        >>> factorial2(7, exact=False)
        array(105.00000000000001)
        >>> factorial2(7, exact=True)
        105L
",function,"('(*args, **kwds)',)",scipy,1.1.0,scipy.misc.factorial2,misc,factorial2,"Python Library Documentation: function factorial2 in module numpy.lib.utils

factorial2(*args, **kwds)
    `factorial2` is deprecated!
    Importing `factorial2` from scipy.misc is deprecated in scipy 1.0.0. Use `scipy.special.factorial2` instead.
    
    Double factorial.
    
        This is the factorial with every second value skipped.  E.g., ``7!! = 7 * 5
        * 3 * 1``.  It can be approximated numerically as::
    
          n!! = special.gamma(n/2+1)*2**((m+1)/2)/sqrt(pi)  n odd
              = 2**(n/2) * (n/2)!                           n even
    
        Parameters
        ----------
        n : int or array_like
            Calculate ``n!!``.  Arrays are only supported with `exact` set
            to False.  If ``n < 0``, the return value is 0.
        exact : bool, optional
            The result can be approximated rapidly using the gamma-formula
            above (default).  If `exact` is set to True, calculate the
            answer exactly using integer arithmetic.
    
        Returns
        -------
        nff : float or int
            Double factorial of `n`, as an int or a float depending on
            `exact`.
    
        Examples
        --------
        >>> from scipy.special import factorial2
        >>> factorial2(7, exact=False)
        array(105.00000000000001)
        >>> factorial2(7, exact=True)
        105L
",function,(),(),(),(),"('(*args, **kwds)',)"
scipy,1.1.0,scipy.misc.factorialk,misc,factorialk,"Python Library Documentation: function factorialk in module numpy.lib.utils

factorialk(*args, **kwds)
    `factorialk` is deprecated!
    Importing `factorialk` from scipy.misc is deprecated in scipy 1.0.0. Use `scipy.special.factorialk` instead.
    
    Multifactorial of n of order k, n(!!...!).
    
        This is the multifactorial of n skipping k values.  For example,
    
          factorialk(17, 4) = 17!!!! = 17 * 13 * 9 * 5 * 1
    
        In particular, for any integer ``n``, we have
    
          factorialk(n, 1) = factorial(n)
    
          factorialk(n, 2) = factorial2(n)
    
        Parameters
        ----------
        n : int
            Calculate multifactorial. If `n` < 0, the return value is 0.
        k : int
            Order of multifactorial.
        exact : bool, optional
            If exact is set to True, calculate the answer exactly using
            integer arithmetic.
    
        Returns
        -------
        val : int
            Multifactorial of `n`.
    
        Raises
        ------
        NotImplementedError
            Raises when exact is False
    
        Examples
        --------
        >>> from scipy.special import factorialk
        >>> factorialk(5, 1, exact=True)
        120L
        >>> factorialk(5, 3, exact=True)
        10L
",function,"('(*args, **kwds)',)",scipy,1.1.0,scipy.misc.factorialk,misc,factorialk,"Python Library Documentation: function factorialk in module numpy.lib.utils

factorialk(*args, **kwds)
    `factorialk` is deprecated!
    Importing `factorialk` from scipy.misc is deprecated in scipy 1.0.0. Use `scipy.special.factorialk` instead.
    
    Multifactorial of n of order k, n(!!...!).
    
        This is the multifactorial of n skipping k values.  For example,
    
          factorialk(17, 4) = 17!!!! = 17 * 13 * 9 * 5 * 1
    
        In particular, for any integer ``n``, we have
    
          factorialk(n, 1) = factorial(n)
    
          factorialk(n, 2) = factorial2(n)
    
        Parameters
        ----------
        n : int
            Calculate multifactorial. If `n` < 0, the return value is 0.
        k : int
            Order of multifactorial.
        exact : bool, optional
            If exact is set to True, calculate the answer exactly using
            integer arithmetic.
    
        Returns
        -------
        val : int
            Multifactorial of `n`.
    
        Raises
        ------
        NotImplementedError
            Raises when exact is False
    
        Examples
        --------
        >>> from scipy.special import factorialk
        >>> factorialk(5, 1, exact=True)
        120L
        >>> factorialk(5, 3, exact=True)
        10L
",function,(),(),(),(),"('(*args, **kwds)',)"
scipy,1.1.0,scipy.misc.fromimage,misc,fromimage,"Python Library Documentation: function fromimage in module numpy.lib.utils

fromimage(*args, **kwds)
    `fromimage` is deprecated!
    `fromimage` is deprecated in SciPy 1.0.0. and will be removed in 1.2.0.
    Use ``np.asarray(im)`` instead.
    
    
        Return a copy of a PIL image as a numpy array.
    
        This function is only available if Python Imaging Library (PIL) is installed.
    
        Parameters
        ----------
        im : PIL image
            Input image.
        flatten : bool
            If true, convert the output to grey-scale.
        mode : str, optional
            Mode to convert image to, e.g. ``'RGB'``.  See the Notes of the
            `imread` docstring for more details.
    
        Returns
        -------
        fromimage : ndarray
            The different colour bands/channels are stored in the
            third dimension, such that a grey-image is MxN, an
            RGB-image MxNx3 and an RGBA-image MxNx4.
",function,"('(*args, **kwds)',)",scipy,1.1.0,scipy.misc.fromimage,misc,fromimage,"Python Library Documentation: function fromimage in module numpy.lib.utils

fromimage(*args, **kwds)
    `fromimage` is deprecated!
    `fromimage` is deprecated in SciPy 1.0.0. and will be removed in 1.2.0.
    Use ``np.asarray(im)`` instead.
    
    
        Return a copy of a PIL image as a numpy array.
    
        This function is only available if Python Imaging Library (PIL) is installed.
    
        Parameters
        ----------
        im : PIL image
            Input image.
        flatten : bool
            If true, convert the output to grey-scale.
        mode : str, optional
            Mode to convert image to, e.g. ``'RGB'``.  See the Notes of the
            `imread` docstring for more details.
    
        Returns
        -------
        fromimage : ndarray
            The different colour bands/channels are stored in the
            third dimension, such that a grey-image is MxN, an
            RGB-image MxNx3 and an RGBA-image MxNx4.
",function,(),(),(),(),"('(*args, **kwds)',)"
scipy,1.1.0,scipy.misc.imfilter,misc,imfilter,"Python Library Documentation: function imfilter in module numpy.lib.utils

imfilter(*args, **kwds)
    `imfilter` is deprecated!
    `imfilter` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.
    Use Pillow filtering functionality directly.
    
    
        Simple filtering of an image.
    
        This function is only available if Python Imaging Library (PIL) is installed.
    
        .. warning::
    
            This function uses `bytescale` under the hood to rescale images to use
            the full (0, 255) range if ``mode`` is one of ``None, 'L', 'P', 'l'``.
            It will also cast data for 2-D images to ``uint32`` for ``mode=None``
            (which is the default).
    
        Parameters
        ----------
        arr : ndarray
            The array of Image in which the filter is to be applied.
        ftype : str
            The filter that has to be applied. Legal values are:
            'blur', 'contour', 'detail', 'edge_enhance', 'edge_enhance_more',
            'emboss', 'find_edges', 'smooth', 'smooth_more', 'sharpen'.
    
        Returns
        -------
        imfilter : ndarray
            The array with filter applied.
    
        Raises
        ------
        ValueError
            *Unknown filter type.*  If the filter you are trying
            to apply is unsupported.
",function,"('(*args, **kwds)',)",scipy,1.1.0,scipy.misc.imfilter,misc,imfilter,"Python Library Documentation: function imfilter in module numpy.lib.utils

imfilter(*args, **kwds)
    `imfilter` is deprecated!
    `imfilter` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.
    Use Pillow filtering functionality directly.
    
    
        Simple filtering of an image.
    
        This function is only available if Python Imaging Library (PIL) is installed.
    
        .. warning::
    
            This function uses `bytescale` under the hood to rescale images to use
            the full (0, 255) range if ``mode`` is one of ``None, 'L', 'P', 'l'``.
            It will also cast data for 2-D images to ``uint32`` for ``mode=None``
            (which is the default).
    
        Parameters
        ----------
        arr : ndarray
            The array of Image in which the filter is to be applied.
        ftype : str
            The filter that has to be applied. Legal values are:
            'blur', 'contour', 'detail', 'edge_enhance', 'edge_enhance_more',
            'emboss', 'find_edges', 'smooth', 'smooth_more', 'sharpen'.
    
        Returns
        -------
        imfilter : ndarray
            The array with filter applied.
    
        Raises
        ------
        ValueError
            *Unknown filter type.*  If the filter you are trying
            to apply is unsupported.
",function,(),(),(),(),"('(*args, **kwds)',)"
scipy,1.1.0,scipy.misc.imread,misc,imread,"Python Library Documentation: function imread in module numpy.lib.utils

imread(*args, **kwds)
    `imread` is deprecated!
    `imread` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.
    Use ``imageio.imread`` instead.
    
    
        Read an image from a file as an array.
    
        This function is only available if Python Imaging Library (PIL) is installed.
    
        Parameters
        ----------
        name : str or file object
            The file name or file object to be read.
        flatten : bool, optional
            If True, flattens the color layers into a single gray-scale layer.
        mode : str, optional
            Mode to convert image to, e.g. ``'RGB'``.  See the Notes for more
            details.
    
        Returns
        -------
        imread : ndarray
            The array obtained by reading the image.
    
        Notes
        -----
        `imread` uses the Python Imaging Library (PIL) to read an image.
        The following notes are from the PIL documentation.
    
        `mode` can be one of the following strings:
    
        * 'L' (8-bit pixels, black and white)
        * 'P' (8-bit pixels, mapped to any other mode using a color palette)
        * 'RGB' (3x8-bit pixels, true color)
        * 'RGBA' (4x8-bit pixels, true color with transparency mask)
        * 'CMYK' (4x8-bit pixels, color separation)
        * 'YCbCr' (3x8-bit pixels, color video format)
        * 'I' (32-bit signed integer pixels)
        * 'F' (32-bit floating point pixels)
    
        PIL also provides limited support for a few special modes, including
        'LA' ('L' with alpha), 'RGBX' (true color with padding) and 'RGBa'
        (true color with premultiplied alpha).
    
        When translating a color image to black and white (mode 'L', 'I' or
        'F'), the library uses the ITU-R 601-2 luma transform::
    
            L = R * 299/1000 + G * 587/1000 + B * 114/1000
    
        When `flatten` is True, the image is converted using mode 'F'.
        When `mode` is not None and `flatten` is True, the image is first
        converted according to `mode`, and the result is then flattened using
        mode 'F'.
",function,"('(*args, **kwds)',)",scipy,1.1.0,scipy.misc.imread,misc,imread,"Python Library Documentation: function imread in module numpy.lib.utils

imread(*args, **kwds)
    `imread` is deprecated!
    `imread` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.
    Use ``imageio.imread`` instead.
    
    
        Read an image from a file as an array.
    
        This function is only available if Python Imaging Library (PIL) is installed.
    
        Parameters
        ----------
        name : str or file object
            The file name or file object to be read.
        flatten : bool, optional
            If True, flattens the color layers into a single gray-scale layer.
        mode : str, optional
            Mode to convert image to, e.g. ``'RGB'``.  See the Notes for more
            details.
    
        Returns
        -------
        imread : ndarray
            The array obtained by reading the image.
    
        Notes
        -----
        `imread` uses the Python Imaging Library (PIL) to read an image.
        The following notes are from the PIL documentation.
    
        `mode` can be one of the following strings:
    
        * 'L' (8-bit pixels, black and white)
        * 'P' (8-bit pixels, mapped to any other mode using a color palette)
        * 'RGB' (3x8-bit pixels, true color)
        * 'RGBA' (4x8-bit pixels, true color with transparency mask)
        * 'CMYK' (4x8-bit pixels, color separation)
        * 'YCbCr' (3x8-bit pixels, color video format)
        * 'I' (32-bit signed integer pixels)
        * 'F' (32-bit floating point pixels)
    
        PIL also provides limited support for a few special modes, including
        'LA' ('L' with alpha), 'RGBX' (true color with padding) and 'RGBa'
        (true color with premultiplied alpha).
    
        When translating a color image to black and white (mode 'L', 'I' or
        'F'), the library uses the ITU-R 601-2 luma transform::
    
            L = R * 299/1000 + G * 587/1000 + B * 114/1000
    
        When `flatten` is True, the image is converted using mode 'F'.
        When `mode` is not None and `flatten` is True, the image is first
        converted according to `mode`, and the result is then flattened using
        mode 'F'.
",function,(),(),(),(),"('(*args, **kwds)',)"
scipy,1.1.0,scipy.misc.imresize,misc,imresize,"Python Library Documentation: function imresize in module numpy.lib.utils

imresize(*args, **kwds)
    `imresize` is deprecated!
    `imresize` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.
    Use ``skimage.transform.resize`` instead.
    
    
        Resize an image.
    
        This function is only available if Python Imaging Library (PIL) is installed.
    
        .. warning::
    
            This function uses `bytescale` under the hood to rescale images to use
            the full (0, 255) range if ``mode`` is one of ``None, 'L', 'P', 'l'``.
            It will also cast data for 2-D images to ``uint32`` for ``mode=None``
            (which is the default).
    
        Parameters
        ----------
        arr : ndarray
            The array of image to be resized.
        size : int, float or tuple
            * int   - Percentage of current size.
            * float - Fraction of current size.
            * tuple - Size of the output image (height, width).
    
        interp : str, optional
            Interpolation to use for re-sizing ('nearest', 'lanczos', 'bilinear',
            'bicubic' or 'cubic').
        mode : str, optional
            The PIL image mode ('P', 'L', etc.) to convert `arr` before resizing.
            If ``mode=None`` (the default), 2-D images will be treated like
            ``mode='L'``, i.e. casting to long integer.  For 3-D and 4-D arrays,
            `mode` will be set to ``'RGB'`` and ``'RGBA'`` respectively.
    
        Returns
        -------
        imresize : ndarray
            The resized array of image.
    
        See Also
        --------
        toimage : Implicitly used to convert `arr` according to `mode`.
        scipy.ndimage.zoom : More generic implementation that does not use PIL.
",function,"('(*args, **kwds)',)",scipy,1.1.0,scipy.misc.imresize,misc,imresize,"Python Library Documentation: function imresize in module numpy.lib.utils

imresize(*args, **kwds)
    `imresize` is deprecated!
    `imresize` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.
    Use ``skimage.transform.resize`` instead.
    
    
        Resize an image.
    
        This function is only available if Python Imaging Library (PIL) is installed.
    
        .. warning::
    
            This function uses `bytescale` under the hood to rescale images to use
            the full (0, 255) range if ``mode`` is one of ``None, 'L', 'P', 'l'``.
            It will also cast data for 2-D images to ``uint32`` for ``mode=None``
            (which is the default).
    
        Parameters
        ----------
        arr : ndarray
            The array of image to be resized.
        size : int, float or tuple
            * int   - Percentage of current size.
            * float - Fraction of current size.
            * tuple - Size of the output image (height, width).
    
        interp : str, optional
            Interpolation to use for re-sizing ('nearest', 'lanczos', 'bilinear',
            'bicubic' or 'cubic').
        mode : str, optional
            The PIL image mode ('P', 'L', etc.) to convert `arr` before resizing.
            If ``mode=None`` (the default), 2-D images will be treated like
            ``mode='L'``, i.e. casting to long integer.  For 3-D and 4-D arrays,
            `mode` will be set to ``'RGB'`` and ``'RGBA'`` respectively.
    
        Returns
        -------
        imresize : ndarray
            The resized array of image.
    
        See Also
        --------
        toimage : Implicitly used to convert `arr` according to `mode`.
        scipy.ndimage.zoom : More generic implementation that does not use PIL.
",function,(),(),(),(),"('(*args, **kwds)',)"
scipy,1.1.0,scipy.misc.imrotate,misc,imrotate,"Python Library Documentation: function imrotate in module numpy.lib.utils

imrotate(*args, **kwds)
    `imrotate` is deprecated!
    `imrotate` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.
    Use ``skimage.transform.rotate`` instead.
    
    
        Rotate an image counter-clockwise by angle degrees.
    
        This function is only available if Python Imaging Library (PIL) is installed.
    
        .. warning::
    
            This function uses `bytescale` under the hood to rescale images to use
            the full (0, 255) range if ``mode`` is one of ``None, 'L', 'P', 'l'``.
            It will also cast data for 2-D images to ``uint32`` for ``mode=None``
            (which is the default).
    
        Parameters
        ----------
        arr : ndarray
            Input array of image to be rotated.
        angle : float
            The angle of rotation.
        interp : str, optional
            Interpolation
    
            - 'nearest' :  for nearest neighbor
            - 'bilinear' : for bilinear
            - 'lanczos' : for lanczos
            - 'cubic' : for bicubic
            - 'bicubic' : for bicubic
    
        Returns
        -------
        imrotate : ndarray
            The rotated array of image.
",function,"('(*args, **kwds)',)",scipy,1.1.0,scipy.misc.imrotate,misc,imrotate,"Python Library Documentation: function imrotate in module numpy.lib.utils

imrotate(*args, **kwds)
    `imrotate` is deprecated!
    `imrotate` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.
    Use ``skimage.transform.rotate`` instead.
    
    
        Rotate an image counter-clockwise by angle degrees.
    
        This function is only available if Python Imaging Library (PIL) is installed.
    
        .. warning::
    
            This function uses `bytescale` under the hood to rescale images to use
            the full (0, 255) range if ``mode`` is one of ``None, 'L', 'P', 'l'``.
            It will also cast data for 2-D images to ``uint32`` for ``mode=None``
            (which is the default).
    
        Parameters
        ----------
        arr : ndarray
            Input array of image to be rotated.
        angle : float
            The angle of rotation.
        interp : str, optional
            Interpolation
    
            - 'nearest' :  for nearest neighbor
            - 'bilinear' : for bilinear
            - 'lanczos' : for lanczos
            - 'cubic' : for bicubic
            - 'bicubic' : for bicubic
    
        Returns
        -------
        imrotate : ndarray
            The rotated array of image.
",function,(),(),(),(),"('(*args, **kwds)',)"
scipy,1.1.0,scipy.misc.imsave,misc,imsave,"Python Library Documentation: function imsave in module numpy.lib.utils

imsave(*args, **kwds)
    `imsave` is deprecated!
    `imsave` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.
    Use ``imageio.imwrite`` instead.
    
    
        Save an array as an image.
    
        This function is only available if Python Imaging Library (PIL) is installed.
    
        .. warning::
    
            This function uses `bytescale` under the hood to rescale images to use
            the full (0, 255) range if ``mode`` is one of ``None, 'L', 'P', 'l'``.
            It will also cast data for 2-D images to ``uint32`` for ``mode=None``
            (which is the default).
    
        Parameters
        ----------
        name : str or file object
            Output file name or file object.
        arr : ndarray, MxN or MxNx3 or MxNx4
            Array containing image values.  If the shape is ``MxN``, the array
            represents a grey-level image.  Shape ``MxNx3`` stores the red, green
            and blue bands along the last dimension.  An alpha layer may be
            included, specified as the last colour band of an ``MxNx4`` array.
        format : str
            Image format. If omitted, the format to use is determined from the
            file name extension. If a file object was used instead of a file name,
            this parameter should always be used.
    
        Examples
        --------
        Construct an array of gradient intensity values and save to file:
    
        >>> from scipy.misc import imsave
        >>> x = np.zeros((255, 255))
        >>> x = np.zeros((255, 255), dtype=np.uint8)
        >>> x[:] = np.arange(255)
        >>> imsave('gradient.png', x)
    
        Construct an array with three colour bands (R, G, B) and store to file:
    
        >>> rgb = np.zeros((255, 255, 3), dtype=np.uint8)
        >>> rgb[..., 0] = np.arange(255)
        >>> rgb[..., 1] = 55
        >>> rgb[..., 2] = 1 - np.arange(255)
        >>> imsave('rgb_gradient.png', rgb)
",function,"('(*args, **kwds)',)",scipy,1.1.0,scipy.misc.imsave,misc,imsave,"Python Library Documentation: function imsave in module numpy.lib.utils

imsave(*args, **kwds)
    `imsave` is deprecated!
    `imsave` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.
    Use ``imageio.imwrite`` instead.
    
    
        Save an array as an image.
    
        This function is only available if Python Imaging Library (PIL) is installed.
    
        .. warning::
    
            This function uses `bytescale` under the hood to rescale images to use
            the full (0, 255) range if ``mode`` is one of ``None, 'L', 'P', 'l'``.
            It will also cast data for 2-D images to ``uint32`` for ``mode=None``
            (which is the default).
    
        Parameters
        ----------
        name : str or file object
            Output file name or file object.
        arr : ndarray, MxN or MxNx3 or MxNx4
            Array containing image values.  If the shape is ``MxN``, the array
            represents a grey-level image.  Shape ``MxNx3`` stores the red, green
            and blue bands along the last dimension.  An alpha layer may be
            included, specified as the last colour band of an ``MxNx4`` array.
        format : str
            Image format. If omitted, the format to use is determined from the
            file name extension. If a file object was used instead of a file name,
            this parameter should always be used.
    
        Examples
        --------
        Construct an array of gradient intensity values and save to file:
    
        >>> from scipy.misc import imsave
        >>> x = np.zeros((255, 255))
        >>> x = np.zeros((255, 255), dtype=np.uint8)
        >>> x[:] = np.arange(255)
        >>> imsave('gradient.png', x)
    
        Construct an array with three colour bands (R, G, B) and store to file:
    
        >>> rgb = np.zeros((255, 255, 3), dtype=np.uint8)
        >>> rgb[..., 0] = np.arange(255)
        >>> rgb[..., 1] = 55
        >>> rgb[..., 2] = 1 - np.arange(255)
        >>> imsave('rgb_gradient.png', rgb)
",function,(),(),(),(),"('(*args, **kwds)',)"
scipy,1.1.0,scipy.misc.imshow,misc,imshow,"Python Library Documentation: function imshow in module numpy.lib.utils

imshow(*args, **kwds)
    `imshow` is deprecated!
    `imshow` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.
    Use ``matplotlib.pyplot.imshow`` instead.
    
    
        Simple showing of an image through an external viewer.
    
        This function is only available if Python Imaging Library (PIL) is installed.
    
        Uses the image viewer specified by the environment variable
        SCIPY_PIL_IMAGE_VIEWER, or if that is not defined then `see`,
        to view a temporary file generated from array data.
    
        .. warning::
    
            This function uses `bytescale` under the hood to rescale images to use
            the full (0, 255) range if ``mode`` is one of ``None, 'L', 'P', 'l'``.
            It will also cast data for 2-D images to ``uint32`` for ``mode=None``
            (which is the default).
    
        Parameters
        ----------
        arr : ndarray
            Array of image data to show.
    
        Returns
        -------
        None
    
        Examples
        --------
        >>> a = np.tile(np.arange(255), (255,1))
        >>> from scipy import misc
        >>> misc.imshow(a)
",function,"('(*args, **kwds)',)",scipy,1.1.0,scipy.misc.imshow,misc,imshow,"Python Library Documentation: function imshow in module numpy.lib.utils

imshow(*args, **kwds)
    `imshow` is deprecated!
    `imshow` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.
    Use ``matplotlib.pyplot.imshow`` instead.
    
    
        Simple showing of an image through an external viewer.
    
        This function is only available if Python Imaging Library (PIL) is installed.
    
        Uses the image viewer specified by the environment variable
        SCIPY_PIL_IMAGE_VIEWER, or if that is not defined then `see`,
        to view a temporary file generated from array data.
    
        .. warning::
    
            This function uses `bytescale` under the hood to rescale images to use
            the full (0, 255) range if ``mode`` is one of ``None, 'L', 'P', 'l'``.
            It will also cast data for 2-D images to ``uint32`` for ``mode=None``
            (which is the default).
    
        Parameters
        ----------
        arr : ndarray
            Array of image data to show.
    
        Returns
        -------
        None
    
        Examples
        --------
        >>> a = np.tile(np.arange(255), (255,1))
        >>> from scipy import misc
        >>> misc.imshow(a)
",function,(),(),(),(),"('(*args, **kwds)',)"
scipy,1.1.0,scipy.misc.info,misc,info,"Python Library Documentation: function info in module numpy.lib.utils

info(*args, **kwds)
    Get help information for a function, class, or module.
    
    Parameters
    ----------
    object : object or str, optional
        Input object or name to get information about. If `object` is a
        numpy object, its docstring is given. If it is a string, available
        modules are searched for matching objects.  If None, information
        about `info` itself is returned.
    maxwidth : int, optional
        Printing width.
    output : file like object, optional
        File like object that the output is written to, default is
        ``stdout``.  The object has to be opened in 'w' or 'a' mode.
    toplevel : str, optional
        Start search at this level.
    
    See Also
    --------
    source, lookfor
    
    Notes
    -----
    When used interactively with an object, ``np.info(obj)`` is equivalent
    to ``help(obj)`` on the Python prompt or ``obj?`` on the IPython
    prompt.
    
    Examples
    --------
    >>> np.info(np.polyval) # doctest: +SKIP
       polyval(p, x)
         Evaluate the polynomial p at x.
         ...
    
    When using a string for `object` it is possible to get multiple results.
    
    >>> np.info('fft') # doctest: +SKIP
         *** Found in numpy ***
    Core FFT routines
    ...
         *** Found in numpy.fft ***
     fft(a, n=None, axis=-1)
    ...
         *** Repeat reference found in numpy.fft.fftpack ***
         *** Total of 3 references found. ***
",function,"('(*args, **kwds)',)",scipy,1.1.0,scipy.misc.info,misc,info,"Python Library Documentation: function info in module numpy.lib.utils

info(*args, **kwds)
    Get help information for a function, class, or module.
    
    Parameters
    ----------
    object : object or str, optional
        Input object or name to get information about. If `object` is a
        numpy object, its docstring is given. If it is a string, available
        modules are searched for matching objects.  If None, information
        about `info` itself is returned.
    maxwidth : int, optional
        Printing width.
    output : file like object, optional
        File like object that the output is written to, default is
        ``stdout``.  The object has to be opened in 'w' or 'a' mode.
    toplevel : str, optional
        Start search at this level.
    
    See Also
    --------
    source, lookfor
    
    Notes
    -----
    When used interactively with an object, ``np.info(obj)`` is equivalent
    to ``help(obj)`` on the Python prompt or ``obj?`` on the IPython
    prompt.
    
    Examples
    --------
    >>> np.info(np.polyval) # doctest: +SKIP
       polyval(p, x)
         Evaluate the polynomial p at x.
         ...
    
    When using a string for `object` it is possible to get multiple results.
    
    >>> np.info('fft') # doctest: +SKIP
         *** Found in numpy ***
    Core FFT routines
    ...
         *** Found in numpy.fft ***
     fft(a, n=None, axis=-1)
    ...
         *** Repeat reference found in numpy.fft.fftpack ***
         *** Total of 3 references found. ***
",function,(),(),(),(),"('(*args, **kwds)',)"
scipy,1.1.0,scipy.misc.logsumexp,misc,logsumexp,"Python Library Documentation: function logsumexp in module numpy.lib.utils

logsumexp(*args, **kwds)
    `logsumexp` is deprecated!
    Importing `logsumexp` from scipy.misc is deprecated in scipy 1.0.0. Use `scipy.special.logsumexp` instead.
    
    Compute the log of the sum of exponentials of input elements.
    
        Parameters
        ----------
        a : array_like
            Input array.
        axis : None or int or tuple of ints, optional
            Axis or axes over which the sum is taken. By default `axis` is None,
            and all elements are summed.
    
            .. versionadded:: 0.11.0
        keepdims : bool, optional
            If this is set to True, the axes which are reduced are left in the
            result as dimensions with size one. With this option, the result
            will broadcast correctly against the original array.
    
            .. versionadded:: 0.15.0
        b : array-like, optional
            Scaling factor for exp(`a`) must be of the same shape as `a` or
            broadcastable to `a`. These values may be negative in order to
            implement subtraction.
    
            .. versionadded:: 0.12.0
        return_sign : bool, optional
            If this is set to True, the result will be a pair containing sign
            information; if False, results that are negative will be returned
            as NaN. Default is False (no sign information).
    
            .. versionadded:: 0.16.0
    
        Returns
        -------
        res : ndarray
            The result, ``np.log(np.sum(np.exp(a)))`` calculated in a numerically
            more stable way. If `b` is given then ``np.log(np.sum(b*np.exp(a)))``
            is returned.
        sgn : ndarray
            If return_sign is True, this will be an array of floating-point
            numbers matching res and +1, 0, or -1 depending on the sign
            of the result. If False, only one result is returned.
    
        See Also
        --------
        numpy.logaddexp, numpy.logaddexp2
    
        Notes
        -----
        Numpy has a logaddexp function which is very similar to `logsumexp`, but
        only handles two arguments. `logaddexp.reduce` is similar to this
        function, but may be less stable.
    
        Examples
        --------
        >>> from scipy.special import logsumexp
        >>> a = np.arange(10)
        >>> np.log(np.sum(np.exp(a)))
        9.4586297444267107
        >>> logsumexp(a)
        9.4586297444267107
    
        With weights
    
        >>> a = np.arange(10)
        >>> b = np.arange(10, 0, -1)
        >>> logsumexp(a, b=b)
        9.9170178533034665
        >>> np.log(np.sum(b*np.exp(a)))
        9.9170178533034647
    
        Returning a sign flag
    
        >>> logsumexp([1,2],b=[1,-1],return_sign=True)
        (1.5413248546129181, -1.0)
    
        Notice that `logsumexp` does not directly support masked arrays. To use it
        on a masked array, convert the mask into zero weights:
    
        >>> a = np.ma.array([np.log(2), 2, np.log(3)],
        ...                  mask=[False, True, False])
        >>> b = (~a.mask).astype(int)
        >>> logsumexp(a.data, b=b), np.log(5)
        1.6094379124341005, 1.6094379124341005
",function,"('(*args, **kwds)',)",scipy,1.1.0,scipy.misc.logsumexp,misc,logsumexp,"Python Library Documentation: function logsumexp in module numpy.lib.utils

logsumexp(*args, **kwds)
    `logsumexp` is deprecated!
    Importing `logsumexp` from scipy.misc is deprecated in scipy 1.0.0. Use `scipy.special.logsumexp` instead.
    
    Compute the log of the sum of exponentials of input elements.
    
        Parameters
        ----------
        a : array_like
            Input array.
        axis : None or int or tuple of ints, optional
            Axis or axes over which the sum is taken. By default `axis` is None,
            and all elements are summed.
    
            .. versionadded:: 0.11.0
        keepdims : bool, optional
            If this is set to True, the axes which are reduced are left in the
            result as dimensions with size one. With this option, the result
            will broadcast correctly against the original array.
    
            .. versionadded:: 0.15.0
        b : array-like, optional
            Scaling factor for exp(`a`) must be of the same shape as `a` or
            broadcastable to `a`. These values may be negative in order to
            implement subtraction.
    
            .. versionadded:: 0.12.0
        return_sign : bool, optional
            If this is set to True, the result will be a pair containing sign
            information; if False, results that are negative will be returned
            as NaN. Default is False (no sign information).
    
            .. versionadded:: 0.16.0
    
        Returns
        -------
        res : ndarray
            The result, ``np.log(np.sum(np.exp(a)))`` calculated in a numerically
            more stable way. If `b` is given then ``np.log(np.sum(b*np.exp(a)))``
            is returned.
        sgn : ndarray
            If return_sign is True, this will be an array of floating-point
            numbers matching res and +1, 0, or -1 depending on the sign
            of the result. If False, only one result is returned.
    
        See Also
        --------
        numpy.logaddexp, numpy.logaddexp2
    
        Notes
        -----
        Numpy has a logaddexp function which is very similar to `logsumexp`, but
        only handles two arguments. `logaddexp.reduce` is similar to this
        function, but may be less stable.
    
        Examples
        --------
        >>> from scipy.special import logsumexp
        >>> a = np.arange(10)
        >>> np.log(np.sum(np.exp(a)))
        9.4586297444267107
        >>> logsumexp(a)
        9.4586297444267107
    
        With weights
    
        >>> a = np.arange(10)
        >>> b = np.arange(10, 0, -1)
        >>> logsumexp(a, b=b)
        9.9170178533034665
        >>> np.log(np.sum(b*np.exp(a)))
        9.9170178533034647
    
        Returning a sign flag
    
        >>> logsumexp([1,2],b=[1,-1],return_sign=True)
        (1.5413248546129181, -1.0)
    
        Notice that `logsumexp` does not directly support masked arrays. To use it
        on a masked array, convert the mask into zero weights:
    
        >>> a = np.ma.array([np.log(2), 2, np.log(3)],
        ...                  mask=[False, True, False])
        >>> b = (~a.mask).astype(int)
        >>> logsumexp(a.data, b=b), np.log(5)
        1.6094379124341005, 1.6094379124341005
",function,(),(),(),(),"('(*args, **kwds)',)"
scipy,1.1.0,scipy.misc.pade,misc,pade,"Python Library Documentation: function pade in module numpy.lib.utils

pade(*args, **kwds)
    `pade` is deprecated!
    Importing `pade` from scipy.misc is deprecated in scipy 1.0.0. Use `scipy.interpolate.pade` instead.
    
    
        Return Pade approximation to a polynomial as the ratio of two polynomials.
    
        Parameters
        ----------
        an : (N,) array_like
            Taylor series coefficients.
        m : int
            The order of the returned approximating polynomials.
    
        Returns
        -------
        p, q : Polynomial class
            The Pade approximation of the polynomial defined by `an` is
            ``p(x)/q(x)``.
    
        Examples
        --------
        >>> from scipy.interpolate import pade
        >>> e_exp = [1.0, 1.0, 1.0/2.0, 1.0/6.0, 1.0/24.0, 1.0/120.0]
        >>> p, q = pade(e_exp, 2)
    
        >>> e_exp.reverse()
        >>> e_poly = np.poly1d(e_exp)
    
        Compare ``e_poly(x)`` and the Pade approximation ``p(x)/q(x)``
    
        >>> e_poly(1)
        2.7166666666666668
    
        >>> p(1)/q(1)
        2.7179487179487181
",function,"('(*args, **kwds)',)",scipy,1.1.0,scipy.misc.pade,misc,pade,"Python Library Documentation: function pade in module numpy.lib.utils

pade(*args, **kwds)
    `pade` is deprecated!
    Importing `pade` from scipy.misc is deprecated in scipy 1.0.0. Use `scipy.interpolate.pade` instead.
    
    
        Return Pade approximation to a polynomial as the ratio of two polynomials.
    
        Parameters
        ----------
        an : (N,) array_like
            Taylor series coefficients.
        m : int
            The order of the returned approximating polynomials.
    
        Returns
        -------
        p, q : Polynomial class
            The Pade approximation of the polynomial defined by `an` is
            ``p(x)/q(x)``.
    
        Examples
        --------
        >>> from scipy.interpolate import pade
        >>> e_exp = [1.0, 1.0, 1.0/2.0, 1.0/6.0, 1.0/24.0, 1.0/120.0]
        >>> p, q = pade(e_exp, 2)
    
        >>> e_exp.reverse()
        >>> e_poly = np.poly1d(e_exp)
    
        Compare ``e_poly(x)`` and the Pade approximation ``p(x)/q(x)``
    
        >>> e_poly(1)
        2.7166666666666668
    
        >>> p(1)/q(1)
        2.7179487179487181
",function,(),(),(),(),"('(*args, **kwds)',)"
scipy,1.1.0,scipy.misc.source,misc,source,"Python Library Documentation: function source in module numpy.lib.utils

source(*args, **kwds)
    `source` is deprecated!
    Importing `source` from scipy.misc is deprecated in scipy 1.0.0. Use `numpy.source` instead.
    
    
        Print or write to a file the source code for a NumPy object.
    
        The source code is only returned for objects written in Python. Many
        functions and classes are defined in C and will therefore not return
        useful information.
    
        Parameters
        ----------
        object : numpy object
            Input object. This can be any object (function, class, module,
            ...).
        output : file object, optional
            If `output` not supplied then source code is printed to screen
            (sys.stdout).  File object must be created with either write 'w' or
            append 'a' modes.
    
        See Also
        --------
        lookfor, info
    
        Examples
        --------
        >>> np.source(np.interp)                        #doctest: +SKIP
        In file: /usr/lib/python2.6/dist-packages/numpy/lib/function_base.py
        def interp(x, xp, fp, left=None, right=None):
            """""".... (full docstring printed)""""""
            if isinstance(x, (float, int, number)):
                return compiled_interp([x], xp, fp, left, right).item()
            else:
                return compiled_interp(x, xp, fp, left, right)
    
        The source code is only returned for objects written in Python.
    
        >>> np.source(np.array)                         #doctest: +SKIP
        Not available for this object.
",function,"('(*args, **kwds)',)",scipy,1.1.0,scipy.misc.source,misc,source,"Python Library Documentation: function source in module numpy.lib.utils

source(*args, **kwds)
    `source` is deprecated!
    Importing `source` from scipy.misc is deprecated in scipy 1.0.0. Use `numpy.source` instead.
    
    
        Print or write to a file the source code for a NumPy object.
    
        The source code is only returned for objects written in Python. Many
        functions and classes are defined in C and will therefore not return
        useful information.
    
        Parameters
        ----------
        object : numpy object
            Input object. This can be any object (function, class, module,
            ...).
        output : file object, optional
            If `output` not supplied then source code is printed to screen
            (sys.stdout).  File object must be created with either write 'w' or
            append 'a' modes.
    
        See Also
        --------
        lookfor, info
    
        Examples
        --------
        >>> np.source(np.interp)                        #doctest: +SKIP
        In file: /usr/lib/python2.6/dist-packages/numpy/lib/function_base.py
        def interp(x, xp, fp, left=None, right=None):
            """""".... (full docstring printed)""""""
            if isinstance(x, (float, int, number)):
                return compiled_interp([x], xp, fp, left, right).item()
            else:
                return compiled_interp(x, xp, fp, left, right)
    
        The source code is only returned for objects written in Python.
    
        >>> np.source(np.array)                         #doctest: +SKIP
        Not available for this object.
",function,(),(),(),(),"('(*args, **kwds)',)"
scipy,1.1.0,scipy.misc.toimage,misc,toimage,"Python Library Documentation: function toimage in module numpy.lib.utils

toimage(*args, **kwds)
    `toimage` is deprecated!
    `toimage` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.
    Use Pillow's ``Image.fromarray`` directly instead.
    
    Takes a numpy array and returns a PIL image.
    
        This function is only available if Python Imaging Library (PIL) is installed.
    
        The mode of the PIL image depends on the array shape and the `pal` and
        `mode` keywords.
    
        For 2-D arrays, if `pal` is a valid (N,3) byte-array giving the RGB values
        (from 0 to 255) then ``mode='P'``, otherwise ``mode='L'``, unless mode
        is given as 'F' or 'I' in which case a float and/or integer array is made.
    
        .. warning::
    
            This function uses `bytescale` under the hood to rescale images to use
            the full (0, 255) range if ``mode`` is one of ``None, 'L', 'P', 'l'``.
            It will also cast data for 2-D images to ``uint32`` for ``mode=None``
            (which is the default).
    
        Notes
        -----
        For 3-D arrays, the `channel_axis` argument tells which dimension of the
        array holds the channel data.
    
        For 3-D arrays if one of the dimensions is 3, the mode is 'RGB'
        by default or 'YCbCr' if selected.
    
        The numpy array must be either 2 dimensional or 3 dimensional.
",function,"('(*args, **kwds)',)",scipy,1.1.0,scipy.misc.toimage,misc,toimage,"Python Library Documentation: function toimage in module numpy.lib.utils

toimage(*args, **kwds)
    `toimage` is deprecated!
    `toimage` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.
    Use Pillow's ``Image.fromarray`` directly instead.
    
    Takes a numpy array and returns a PIL image.
    
        This function is only available if Python Imaging Library (PIL) is installed.
    
        The mode of the PIL image depends on the array shape and the `pal` and
        `mode` keywords.
    
        For 2-D arrays, if `pal` is a valid (N,3) byte-array giving the RGB values
        (from 0 to 255) then ``mode='P'``, otherwise ``mode='L'``, unless mode
        is given as 'F' or 'I' in which case a float and/or integer array is made.
    
        .. warning::
    
            This function uses `bytescale` under the hood to rescale images to use
            the full (0, 255) range if ``mode`` is one of ``None, 'L', 'P', 'l'``.
            It will also cast data for 2-D images to ``uint32`` for ``mode=None``
            (which is the default).
    
        Notes
        -----
        For 3-D arrays, the `channel_axis` argument tells which dimension of the
        array holds the channel data.
    
        For 3-D arrays if one of the dimensions is 3, the mode is 'RGB'
        by default or 'YCbCr' if selected.
    
        The numpy array must be either 2 dimensional or 3 dimensional.
",function,(),(),(),(),"('(*args, **kwds)',)"
scipy,1.1.0,scipy.misc.who,misc,who,"Python Library Documentation: function who in module numpy.lib.utils

who(*args, **kwds)
    `who` is deprecated!
    Importing `who` from scipy.misc is deprecated in scipy 1.0.0. Use `numpy.who` instead.
    
    
        Print the NumPy arrays in the given dictionary.
    
        If there is no dictionary passed in or `vardict` is None then returns
        NumPy arrays in the globals() dictionary (all NumPy arrays in the
        namespace).
    
        Parameters
        ----------
        vardict : dict, optional
            A dictionary possibly containing ndarrays.  Default is globals().
    
        Returns
        -------
        out : None
            Returns 'None'.
    
        Notes
        -----
        Prints out the name, shape, bytes and type of all of the ndarrays
        present in `vardict`.
    
        Examples
        --------
        >>> a = np.arange(10)
        >>> b = np.ones(20)
        >>> np.who()
        Name            Shape            Bytes            Type
        ===========================================================
        a               10               40               int32
        b               20               160              float64
        Upper bound on total bytes  =       200
    
        >>> d = {'x': np.arange(2.0), 'y': np.arange(3.0), 'txt': 'Some str',
        ... 'idx':5}
        >>> np.who(d)
        Name            Shape            Bytes            Type
        ===========================================================
        y               3                24               float64
        x               2                16               float64
        Upper bound on total bytes  =       40
",function,"('(*args, **kwds)',)",scipy,1.1.0,scipy.misc.who,misc,who,"Python Library Documentation: function who in module numpy.lib.utils

who(*args, **kwds)
    `who` is deprecated!
    Importing `who` from scipy.misc is deprecated in scipy 1.0.0. Use `numpy.who` instead.
    
    
        Print the NumPy arrays in the given dictionary.
    
        If there is no dictionary passed in or `vardict` is None then returns
        NumPy arrays in the globals() dictionary (all NumPy arrays in the
        namespace).
    
        Parameters
        ----------
        vardict : dict, optional
            A dictionary possibly containing ndarrays.  Default is globals().
    
        Returns
        -------
        out : None
            Returns 'None'.
    
        Notes
        -----
        Prints out the name, shape, bytes and type of all of the ndarrays
        present in `vardict`.
    
        Examples
        --------
        >>> a = np.arange(10)
        >>> b = np.ones(20)
        >>> np.who()
        Name            Shape            Bytes            Type
        ===========================================================
        a               10               40               int32
        b               20               160              float64
        Upper bound on total bytes  =       200
    
        >>> d = {'x': np.arange(2.0), 'y': np.arange(3.0), 'txt': 'Some str',
        ... 'idx':5}
        >>> np.who(d)
        Name            Shape            Bytes            Type
        ===========================================================
        y               3                24               float64
        x               2                16               float64
        Upper bound on total bytes  =       40
",function,(),(),(),(),"('(*args, **kwds)',)"
